summaryrefslogtreecommitdiffstats
path: root/nlpsolver/ThirdParty/EvolutionarySolver/src/net
diff options
context:
space:
mode:
Diffstat (limited to 'nlpsolver/ThirdParty/EvolutionarySolver/src/net')
-rw-r--r--nlpsolver/ThirdParty/EvolutionarySolver/src/net/adaptivebox/Manifest.mf2
-rw-r--r--nlpsolver/ThirdParty/EvolutionarySolver/src/net/adaptivebox/deps/DEPSAgent.java128
-rw-r--r--nlpsolver/ThirdParty/EvolutionarySolver/src/net/adaptivebox/deps/behavior/AbsGTBehavior.java43
-rw-r--r--nlpsolver/ThirdParty/EvolutionarySolver/src/net/adaptivebox/deps/behavior/DEGTBehavior.java122
-rw-r--r--nlpsolver/ThirdParty/EvolutionarySolver/src/net/adaptivebox/deps/behavior/PSGTBehavior.java132
-rw-r--r--nlpsolver/ThirdParty/EvolutionarySolver/src/net/adaptivebox/encode/EvalElement.java68
-rw-r--r--nlpsolver/ThirdParty/EvolutionarySolver/src/net/adaptivebox/encode/EvalStruct.java56
-rw-r--r--nlpsolver/ThirdParty/EvolutionarySolver/src/net/adaptivebox/encode/IEncodeEngine.java24
-rw-r--r--nlpsolver/ThirdParty/EvolutionarySolver/src/net/adaptivebox/global/BasicBound.java64
-rw-r--r--nlpsolver/ThirdParty/EvolutionarySolver/src/net/adaptivebox/global/IUpdateCycleEngine.java24
-rw-r--r--nlpsolver/ThirdParty/EvolutionarySolver/src/net/adaptivebox/global/RandomGenerator.java108
-rw-r--r--nlpsolver/ThirdParty/EvolutionarySolver/src/net/adaptivebox/goodness/ACRComparator.java91
-rw-r--r--nlpsolver/ThirdParty/EvolutionarySolver/src/net/adaptivebox/goodness/BCHComparator.java46
-rw-r--r--nlpsolver/ThirdParty/EvolutionarySolver/src/net/adaptivebox/goodness/IGoodnessCompareEngine.java41
-rw-r--r--nlpsolver/ThirdParty/EvolutionarySolver/src/net/adaptivebox/knowledge/ILibEngine.java27
-rw-r--r--nlpsolver/ThirdParty/EvolutionarySolver/src/net/adaptivebox/knowledge/Library.java106
-rw-r--r--nlpsolver/ThirdParty/EvolutionarySolver/src/net/adaptivebox/knowledge/SearchPoint.java70
-rw-r--r--nlpsolver/ThirdParty/EvolutionarySolver/src/net/adaptivebox/problem/ProblemEncoder.java109
-rw-r--r--nlpsolver/ThirdParty/EvolutionarySolver/src/net/adaptivebox/sco/SCAgent.java143
-rw-r--r--nlpsolver/ThirdParty/EvolutionarySolver/src/net/adaptivebox/space/BasicPoint.java42
-rw-r--r--nlpsolver/ThirdParty/EvolutionarySolver/src/net/adaptivebox/space/DesignDim.java45
-rw-r--r--nlpsolver/ThirdParty/EvolutionarySolver/src/net/adaptivebox/space/DesignSpace.java73
-rw-r--r--nlpsolver/ThirdParty/EvolutionarySolver/src/net/adaptivebox/space/ILocationEngine.java25
23 files changed, 1589 insertions, 0 deletions
diff --git a/nlpsolver/ThirdParty/EvolutionarySolver/src/net/adaptivebox/Manifest.mf b/nlpsolver/ThirdParty/EvolutionarySolver/src/net/adaptivebox/Manifest.mf
new file mode 100644
index 000000000..139597f9c
--- /dev/null
+++ b/nlpsolver/ThirdParty/EvolutionarySolver/src/net/adaptivebox/Manifest.mf
@@ -0,0 +1,2 @@
+
+
diff --git a/nlpsolver/ThirdParty/EvolutionarySolver/src/net/adaptivebox/deps/DEPSAgent.java b/nlpsolver/ThirdParty/EvolutionarySolver/src/net/adaptivebox/deps/DEPSAgent.java
new file mode 100644
index 000000000..3a08df39f
--- /dev/null
+++ b/nlpsolver/ThirdParty/EvolutionarySolver/src/net/adaptivebox/deps/DEPSAgent.java
@@ -0,0 +1,128 @@
+package net.adaptivebox.deps;
+
+/**
+ * Description: The description of agent with hybrid differential evolution and particle swarm.
+ *
+ * @ Author Create/Modi Note
+ * Xiaofeng Xie Jun 10, 2004
+ * Xiaofeng Xie Jul 01, 2008
+ *
+ * This library is free software; you can redistribute it and/or
+ * modify it under the terms of the GNU Lesser General Public
+ * License as published by the Free Software Foundation; either
+ * version 2.1 of the License, or (at your option) any later version.
+ *
+ * This library is distributed in the hope that it will be useful,
+ * but WITHOUT ANY WARRANTY; without even the implied warranty of
+ * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU
+ * Lesser General Public License for more details.
+ *
+ * Please acknowledge the author(s) if you use this code in any way.
+ *
+ * @version 1.0
+ * @Since MAOS1.0
+ *
+ * @References:
+ * [1] Zhang W J, Xie X F. DEPSO: hybrid particle swarm with differential
+ * evolution operator. IEEE International Conference on Systems, Man & Cybernetics,
+ * Washington D C, USA, 2003: 3816-3821
+ * [2] X F Xie, W J Zhang. SWAF: swarm algorithm framework for numerical
+ * optimization. Genetic and Evolutionary Computation Conference (GECCO),
+ * Seattle, WA, USA, 2004: 238-250
+ * -> an agent perspective
+ */
+
+import net.adaptivebox.deps.behavior.AbsGTBehavior;
+import net.adaptivebox.deps.behavior.DEGTBehavior;
+import net.adaptivebox.deps.behavior.PSGTBehavior;
+import net.adaptivebox.global.RandomGenerator;
+import net.adaptivebox.goodness.IGoodnessCompareEngine;
+import net.adaptivebox.knowledge.ILibEngine;
+import net.adaptivebox.knowledge.Library;
+import net.adaptivebox.knowledge.SearchPoint;
+import net.adaptivebox.problem.ProblemEncoder;
+import net.adaptivebox.space.BasicPoint;
+
+public class DEPSAgent {
+
+ // Describes the problem to be solved
+ private ProblemEncoder problemEncoder;
+
+ // Forms the goodness landscape
+ private IGoodnessCompareEngine qualityComparator;
+
+ // store the point that generated in current learning cycle
+ private SearchPoint trailPoint;
+
+ // temp variable
+ private AbsGTBehavior selectGTBehavior;
+
+ // the own memory: store the point that generated in old learning cycle
+ private BasicPoint pold_t;
+
+ // the own memory: store the point that generated in last learning cycle
+ private BasicPoint pcurrent_t;
+
+ // the own memory: store the personal best point
+ private SearchPoint pbest_t;
+
+ // Generate-and-test behaviors.
+ private DEGTBehavior deGTBehavior;
+ private PSGTBehavior psGTBehavior;
+
+ private double switchP = 0.5;
+
+ public DEPSAgent(ProblemEncoder encoder, DEGTBehavior deGTBehavior, PSGTBehavior psGTBehavior,
+ double switchP, IGoodnessCompareEngine comparer, SearchPoint pbest) {
+ this.switchP = switchP;
+
+ problemEncoder = encoder;
+
+ qualityComparator = comparer;
+
+ trailPoint = problemEncoder.getFreshSearchPoint();
+ pold_t = problemEncoder.getFreshSearchPoint();
+ pcurrent_t = problemEncoder.getFreshSearchPoint();
+ pbest_t = pbest;
+
+ this.deGTBehavior = deGTBehavior;
+ this.deGTBehavior.setMemPoints(pbest_t, pcurrent_t, pold_t);
+
+ this.psGTBehavior = psGTBehavior;
+ this.psGTBehavior.setMemPoints(pbest_t, pcurrent_t, pold_t);
+ }
+
+ public void setSpecComparator(IGoodnessCompareEngine comparer) {
+ qualityComparator = comparer;
+ }
+
+ private AbsGTBehavior getGTBehavior() {
+ if (RandomGenerator.doubleZeroOneRandom() < switchP) {
+ return deGTBehavior;
+ } else {
+ return psGTBehavior;
+ }
+ }
+
+ public void setGTBehavior(AbsGTBehavior gtBehavior) {
+ gtBehavior.setMemPoints(pbest_t, pcurrent_t, pold_t);
+ }
+
+ public void generatePoint() {
+ // generates a new point in the search space (S) based on
+ // its memory and the library
+ selectGTBehavior = getGTBehavior();
+ selectGTBehavior.generateBehavior(trailPoint, problemEncoder);
+
+ // evaluate into goodness information
+ problemEncoder.evaluate(trailPoint);
+ }
+
+ public void learn() {
+ selectGTBehavior.testBehavior(trailPoint, qualityComparator);
+ }
+
+ public SearchPoint getMGState() {
+ return trailPoint;
+ }
+}
diff --git a/nlpsolver/ThirdParty/EvolutionarySolver/src/net/adaptivebox/deps/behavior/AbsGTBehavior.java b/nlpsolver/ThirdParty/EvolutionarySolver/src/net/adaptivebox/deps/behavior/AbsGTBehavior.java
new file mode 100644
index 000000000..2701c9dee
--- /dev/null
+++ b/nlpsolver/ThirdParty/EvolutionarySolver/src/net/adaptivebox/deps/behavior/AbsGTBehavior.java
@@ -0,0 +1,43 @@
+/**
+ * Description: The description of generate-and-test behavior.
+ *
+ *
+ * Author Create/Modi Note
+ * Xiaofeng Xie May 17, 2004
+ * Xiaofeng Xie Jul 01, 2008
+ *
+ * @version 1.0
+ * @Since MAOS1.0
+ *
+ * @References:
+ * [1] X F Xie, W J Zhang. SWAF: swarm algorithm framework for numerical
+ * optimization. Genetic and Evolutionary Computation Conference (GECCO),
+ * Seattle, WA, USA, 2004: 238-250
+ * -> a generate-and-test behavior
+ */
+package net.adaptivebox.deps.behavior;
+
+import net.adaptivebox.goodness.IGoodnessCompareEngine;
+import net.adaptivebox.knowledge.ILibEngine;
+import net.adaptivebox.knowledge.Library;
+import net.adaptivebox.knowledge.SearchPoint;
+import net.adaptivebox.problem.ProblemEncoder;
+import net.adaptivebox.space.BasicPoint;
+
+abstract public class AbsGTBehavior implements ILibEngine {
+ // The referred social library
+ protected Library socialLib;
+
+ // the own memory: store the personal best point
+ protected SearchPoint pbest_t;
+
+ public void setLibrary(Library lib) {
+ socialLib = lib;
+ }
+
+ abstract public void setMemPoints(SearchPoint pbest, BasicPoint pcurrent, BasicPoint pold);
+
+ abstract public void generateBehavior(SearchPoint trailPoint, ProblemEncoder problemEncoder);
+
+ abstract public void testBehavior(SearchPoint trailPoint, IGoodnessCompareEngine qualityComparator);
+}
diff --git a/nlpsolver/ThirdParty/EvolutionarySolver/src/net/adaptivebox/deps/behavior/DEGTBehavior.java b/nlpsolver/ThirdParty/EvolutionarySolver/src/net/adaptivebox/deps/behavior/DEGTBehavior.java
new file mode 100644
index 000000000..c9ca0ef82
--- /dev/null
+++ b/nlpsolver/ThirdParty/EvolutionarySolver/src/net/adaptivebox/deps/behavior/DEGTBehavior.java
@@ -0,0 +1,122 @@
+/**
+ * Description: The description of differential evolution Generate-and-Test Behavior.
+
+ #Supported parameters:
+ NAME VALUE_type Range DefaultV Description
+ FACTOR real (0, 1.2] 0.5 DEAgent: scale constant
+ CR real [0, 1] 0.9 DEAgent: crossover constant
+ //Other choices for FACTOR and CR: (0.5, 0.1)
+
+ *
+ * Author Create/Modi Note
+ * Xiaofeng Xie May 11, 2004
+ * Xiaofeng Xie Jul 01, 2008
+ *
+ * @version 1.0
+ * @Since MAOS1.0
+ *
+ * @References:
+ * [1] Storn R, Price K. Differential evolution - a simple and efficient
+ * heuristic for global optimization over continuous spaces. Journal of
+ * Global Optimization, 1997, 11: 341-359
+ * The original differential evolution idea
+ * [2] X F Xie, W J Zhang. SWAF: swarm algorithm framework for numerical
+ * optimization. Genetic and Evolutionary Computation Conference (GECCO),
+ * Seattle, WA, USA, 2004: 238-250
+ * -> a generate-and-test behavior
+ */
+
+package net.adaptivebox.deps.behavior;
+
+import net.adaptivebox.global.RandomGenerator;
+import net.adaptivebox.goodness.IGoodnessCompareEngine;
+import net.adaptivebox.knowledge.Library;
+import net.adaptivebox.knowledge.SearchPoint;
+import net.adaptivebox.problem.ProblemEncoder;
+import net.adaptivebox.space.BasicPoint;
+
+public class DEGTBehavior extends AbsGTBehavior {
+ //Number of differential vectors, normally be 1 or 2
+ private static final int DVNum = 2;
+
+ //scale constant: (0, 1.2], normally be 0.5
+ public double MIN_FACTOR = 0.5;
+
+ //scale constant: (0, 1.2], normally be 0.5
+ public double MAX_FACTOR = 0.5;
+
+ //crossover constant: [0, 1], normally be 0.1 or 0.9
+ public double CR = 0.9;
+
+ @Override
+ public void setMemPoints(SearchPoint pbest, BasicPoint pcurrent, BasicPoint pold) {
+ pbest_t = pbest;
+ }
+
+ /**
+ * Crossover and mutation for a single vector element done in a single step.
+ *
+ * @param index Index of the trial vector element to be changed.
+ * @param trialVector Trial vector reference.
+ * @param globalVector Global best found vector reference.
+ * @param differenceVectors List of vectors used for difference delta
+ * calculation.
+ */
+ private void crossoverAndMutation(int index, double trialVector[], double globalVector[],
+ BasicPoint differenceVectors[]) {
+ double delta = 0D;
+
+ for (int i = 0; i < differenceVectors.length; i++) {
+ delta += (i % 2 == 0 ? +1D : -1D) * differenceVectors[i].getLocation()[index];
+ }
+
+ trialVector[index] = globalVector[index] + RandomGenerator.doubleRangeRandom(MIN_FACTOR, MAX_FACTOR) * delta;
+ }
+
+ @Override
+ public void generateBehavior(SearchPoint trailPoint, ProblemEncoder problemEncoder) {
+ BasicPoint[] referPoints = getReferPoints();
+ int DIMENSION = problemEncoder.getDesignSpace().getDimension();
+ int guaranteeIndex = RandomGenerator.intRangeRandom(0, DIMENSION - 1);
+
+ double[] trailVector = trailPoint.getLocation();
+ double[] locaclVector = pbest_t.getLocation();
+ double[] globalVector = socialLib.getGbest().getLocation();
+
+ /* Handle first part of the trial vector. */
+ for (int index = 0; index < guaranteeIndex; index++) {
+ if (CR <= RandomGenerator.doubleZeroOneRandom()) {
+ trailVector[index] = locaclVector[index];
+ continue;
+ }
+
+ crossoverAndMutation(index, trailVector, globalVector, referPoints);
+ }
+
+ /* Guarantee for at least one change in the trial vector. */
+ crossoverAndMutation(guaranteeIndex, trailVector, globalVector, referPoints);
+
+ /* Handle second part of the trial vector. */
+ for (int index = guaranteeIndex + 1; index < DIMENSION; index++) {
+ if (CR <= RandomGenerator.doubleZeroOneRandom()) {
+ trailVector[index] = locaclVector[index];
+ continue;
+ }
+
+ crossoverAndMutation(index, trailVector, globalVector, referPoints);
+ }
+ }
+
+ @Override
+ public void testBehavior(SearchPoint trailPoint, IGoodnessCompareEngine qualityComparator) {
+ Library.replace(qualityComparator, trailPoint, pbest_t);
+ }
+
+ private SearchPoint[] getReferPoints() {
+ SearchPoint[] referPoints = new SearchPoint[DVNum * 2];
+ for (int i = 0; i < referPoints.length; i++) {
+ referPoints[i] = socialLib.getRandomPoint();
+ }
+ return referPoints;
+ }
+}
diff --git a/nlpsolver/ThirdParty/EvolutionarySolver/src/net/adaptivebox/deps/behavior/PSGTBehavior.java b/nlpsolver/ThirdParty/EvolutionarySolver/src/net/adaptivebox/deps/behavior/PSGTBehavior.java
new file mode 100644
index 000000000..68bf5a10e
--- /dev/null
+++ b/nlpsolver/ThirdParty/EvolutionarySolver/src/net/adaptivebox/deps/behavior/PSGTBehavior.java
@@ -0,0 +1,132 @@
+/**
+ * Description: The description of particle swarm (PS) Generate-and-test Behavior.
+ *
+ #Supported parameters:
+ NAME VALUE_type Range DefaultV Description
+ c1 real [0, 2] 1.494 PSAgent: learning factor for pbest
+ c2 real [0, 2] 1.494 PSAgent: learning factor for gbest
+ w real [0, 1] 0.729 PSAgent: inertia weight
+ CL real [0, 0.1] 0 PSAgent: chaos factor
+ //Other choices for c1, c2, w, and CL: (2, 2, 0.4, 0.001)
+
+ * Author Create/Modi Note
+ * Xiaofeng Xie May 11, 2004
+ * Xiaofeng Xie Jul 01, 2008
+ *
+ * This library is free software; you can redistribute it and/or
+ * modify it under the terms of the GNU Lesser General Public
+ * License as published by the Free Software Foundation; either
+ * version 2.1 of the License, or (at your option) any later version.
+ *
+ * This library is distributed in the hope that it will be useful,
+ * but WITHOUT ANY WARRANTY; without even the implied warranty of
+ * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU
+ * Lesser General Public License for more details.
+ *
+ * Please acknowledge the author(s) if you use this code in any way.
+ *
+ * @version 1.0
+ * @Since MAOS1.0
+ *
+ * References:
+ * [1] Kennedy J, Eberhart R C. Particle swarm optimization. IEEE Int. Conf. on
+ * Neural Networks, Perth, Australia, 1995: 1942-1948
+ * For original particle swarm idea
+ * [2] Shi Y H, Eberhart R C. A Modified Particle Swarm Optimizer. IEEE Inter. Conf.
+ * on Evolutionary Computation, Anchorage, Alaska, 1998: 69-73
+ * For the inertia weight: adjust the trade-off between exploitation & exploration
+ * [3] Clerc M, Kennedy J. The particle swarm - explosion, stability, and
+ * convergence in a multidimensional complex space. IEEE Trans. on Evolutionary
+ * Computation. 2002, 6 (1): 58-73
+ * Constriction factor: ensures the convergence
+ * [4] Xie X F, Zhang W J, Yang Z L. A dissipative particle swarm optimization.
+ * Congress on Evolutionary Computation, Hawaii, USA, 2002: 1456-1461
+ * The CL parameter
+ * [5] Xie X F, Zhang W J, Bi D C. Optimizing semiconductor devices by self-
+ * organizing particle swarm. Congress on Evolutionary Computation, Oregon, USA,
+ * 2004: 2017-2022
+ * Further experimental analysis on the convergence of PSO
+ * [6] X F Xie, W J Zhang. SWAF: swarm algorithm framework for numerical
+ * optimization. Genetic and Evolutionary Computation Conference (GECCO),
+ * Seattle, WA, USA, 2004: 238-250
+ * -> a generate-and-test behavior
+ *
+ */
+
+package net.adaptivebox.deps.behavior;
+
+import net.adaptivebox.global.RandomGenerator;
+import net.adaptivebox.goodness.IGoodnessCompareEngine;
+import net.adaptivebox.knowledge.Library;
+import net.adaptivebox.knowledge.SearchPoint;
+import net.adaptivebox.problem.ProblemEncoder;
+import net.adaptivebox.space.BasicPoint;
+import net.adaptivebox.space.DesignSpace;
+
+public class PSGTBehavior extends AbsGTBehavior {
+ // Two normally choices for (c1, c2, weight), i.e., (2, 2, 0.4), or (1.494,
+ // 1.494, 0.729) The first is used in dissipative PSO (cf. [4]) as CL>0, and
+ // the second is achieved by using constriction factors (cf. [3])
+ public double c1 = 2;
+ public double c2 = 2;
+
+ //inertia weight
+ public double weight = 0.4;
+
+ //See ref[4], normally be 0.001~0.005
+ public double CL = 0;
+
+ // the own memory: store the point that generated in old learning cycle
+ private BasicPoint pold_t;
+
+ // the own memory: store the point that generated in last learning cycle
+ private BasicPoint pcurrent_t;
+
+ @Override
+ public void setMemPoints(SearchPoint pbest, BasicPoint pcurrent, BasicPoint pold) {
+ pcurrent_t = pcurrent;
+ pbest_t = pbest;
+ pold_t = pold;
+ }
+
+ @Override
+ public void generateBehavior(SearchPoint trailPoint, ProblemEncoder problemEncoder) {
+ DesignSpace designSpace = problemEncoder.getDesignSpace();
+
+ double[] pold_t_location = pold_t.getLocation();
+ double[] pbest_t_location = pbest_t.getLocation();
+ double[] pcurrent_t_location = pcurrent_t.getLocation();
+ double[] gbest_t_location = socialLib.getGbest().getLocation();
+ double[] trailPointLocation = trailPoint.getLocation();
+
+ int DIMENSION = designSpace.getDimension();
+ for (int b = 0; b < DIMENSION; b++) {
+ if (RandomGenerator.doubleZeroOneRandom() < CL) {
+ designSpace.mutationAt(trailPointLocation, b);
+ continue;
+ }
+
+ double deltaxb = weight * (pcurrent_t_location[b] - pold_t_location[b])
+ + c1 * RandomGenerator.doubleZeroOneRandom() * (pbest_t_location[b] - pcurrent_t_location[b])
+ + c2 * RandomGenerator.doubleZeroOneRandom() * (gbest_t_location[b] - pcurrent_t_location[b]);
+
+ // limitation for delta_x
+ double deltaxbm = 0.5 * designSpace.getMagnitudeIn(b);
+
+ if (deltaxb < -deltaxbm) {
+ deltaxb = -deltaxbm;
+ } else if (deltaxb > deltaxbm) {
+ deltaxb = deltaxbm;
+ }
+
+ trailPointLocation[b] = pcurrent_t_location[b] + deltaxb;
+ }
+ }
+
+ @Override
+ public void testBehavior(SearchPoint trailPoint, IGoodnessCompareEngine qualityComparator) {
+ Library.replace(qualityComparator, trailPoint, pbest_t);
+ pold_t.importLocation(pcurrent_t);
+ pcurrent_t.importLocation(trailPoint);
+ }
+}
diff --git a/nlpsolver/ThirdParty/EvolutionarySolver/src/net/adaptivebox/encode/EvalElement.java b/nlpsolver/ThirdParty/EvolutionarySolver/src/net/adaptivebox/encode/EvalElement.java
new file mode 100644
index 000000000..85e50c9f9
--- /dev/null
+++ b/nlpsolver/ThirdParty/EvolutionarySolver/src/net/adaptivebox/encode/EvalElement.java
@@ -0,0 +1,68 @@
+/**
+ * Description: provide the information for evaluating of a response (target)
+ *
+ * Author Create/Modi Note
+ * Xiaofeng Xie Mar 1, 2003
+ * Xiaofeng Xie May 11, 2004
+*
+ * This library is free software; you can redistribute it and/or
+ * modify it under the terms of the GNU Lesser General Public
+ * License as published by the Free Software Foundation; either
+ * version 2.1 of the License, or (at your option) any later version.
+ *
+ * This library is distributed in the hope that it will be useful,
+ * but WITHOUT ANY WARRANTY; without even the implied warranty of
+ * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU
+ * Lesser General Public License for more details.
+ *
+ * Please acknowledge the author(s) if you use this code in any way.
+ */
+
+package net.adaptivebox.encode;
+
+import net.adaptivebox.global.BasicBound;
+
+public class EvalElement {
+
+ // The weight for each response (target)
+ private static final double weight = 1;
+ /**
+ * The expected range of the response value, forms the following objective:
+ *
+ * <pre>
+ * NO minValue maxValue : THE ELEMENT OF BasicBound
+ * 1 MINDOUBLE, MINDOUBLE: the minimize objective
+ * 2 MAXDOUBLE, MAXDOUBLE: the maximize objective
+ * 3 MINDOUBLE, v : the less than constraint {@literal (<v)}
+ * 4 v , MAXDOUBLE: the larger than constraint {@literal (>v)}
+ * 5 v1 , v2 : the region constraint, i.e. belongs to [v1, v2]
+ *
+ * OPTIM type: the No.1 and No.2
+ * CONS type: the last three
+ * </pre>
+ */
+ public BasicBound targetBound = new BasicBound();
+
+ public boolean isOptType() {
+ return ((targetBound.minValue == BasicBound.MINDOUBLE && targetBound.maxValue == BasicBound.MINDOUBLE)
+ || (targetBound.minValue == BasicBound.MAXDOUBLE && targetBound.maxValue == BasicBound.MAXDOUBLE));
+ }
+
+ public double evaluateCONS(double targetValue) {
+ if (targetValue < targetBound.minValue) {
+ return weight * (targetBound.minValue - targetValue);
+ }
+ if (targetValue > targetBound.maxValue) {
+ return weight * (targetValue - targetBound.maxValue);
+ }
+ return 0;
+ }
+
+ public double evaluateOPTIM(double targetValue) {
+ if (targetBound.maxValue == BasicBound.MINDOUBLE) { // min mode
+ return weight * targetValue;
+ } else { // max
+ return -weight * targetValue;
+ }
+ }
+}
diff --git a/nlpsolver/ThirdParty/EvolutionarySolver/src/net/adaptivebox/encode/EvalStruct.java b/nlpsolver/ThirdParty/EvolutionarySolver/src/net/adaptivebox/encode/EvalStruct.java
new file mode 100644
index 000000000..db37ddb39
--- /dev/null
+++ b/nlpsolver/ThirdParty/EvolutionarySolver/src/net/adaptivebox/encode/EvalStruct.java
@@ -0,0 +1,56 @@
+/**
+ * Description: provide the information for evaluating a set of targets values
+ * into encoded information (For formation the goodness landscape by comparing)
+ *
+ * Author Create/Modi Note
+ * Xiaofeng Xie Mar 1, 2003
+ * Xiaofeng Xie May 11, 2004
+ *
+ * This library is free software; you can redistribute it and/or
+ * modify it under the terms of the GNU Lesser General Public
+ * License as published by the Free Software Foundation; either
+ * version 2.1 of the License, or (at your option) any later version.
+ *
+ * This library is distributed in the hope that it will be useful,
+ * but WITHOUT ANY WARRANTY; without even the implied warranty of
+ * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU
+ * Lesser General Public License for more details.
+ *
+ * Please acknowledge the author(s) if you use this code in any way.
+ *
+ * @References:
+ * [1] Deb K. An efficient constraint handling method for genetic algorithms.
+ * Computer Methods in Applied Mechanics and Engineering, 2000, 186(2-4): 311-338
+ */
+
+package net.adaptivebox.encode;
+
+public class EvalStruct {
+ // The information for evaluating all the responses
+ private EvalElement[] evalElems = null;
+
+ public EvalStruct(int elemsNum) {
+ evalElems = new EvalElement[elemsNum];
+ }
+
+ public void setElemAt(EvalElement dim, int index) {
+ evalElems[index] = dim;
+ }
+
+ // convert response values into encoded information double[2]
+ public void evaluate(double[] evalRes, double[] targetValues) {
+ evalRes[0] = evalRes[1] = 0;
+ for (int i = 0; i < evalElems.length; i++) {
+ if (evalElems[i].isOptType()) {
+ // The objectives (OPTIM type)
+ // The multi-objective will be translated into single-objective
+ evalRes[1] += evalElems[i].evaluateOPTIM(targetValues[i]);
+ } else {
+ // The constraints (CONS type)
+ // If evalRes[0] equals to 0, then be a feasible point, i.e. satisfies
+ // all the constraints
+ evalRes[0] += evalElems[i].evaluateCONS(targetValues[i]);
+ }
+ }
+ }
+}
diff --git a/nlpsolver/ThirdParty/EvolutionarySolver/src/net/adaptivebox/encode/IEncodeEngine.java b/nlpsolver/ThirdParty/EvolutionarySolver/src/net/adaptivebox/encode/IEncodeEngine.java
new file mode 100644
index 000000000..56f791c41
--- /dev/null
+++ b/nlpsolver/ThirdParty/EvolutionarySolver/src/net/adaptivebox/encode/IEncodeEngine.java
@@ -0,0 +1,24 @@
+/**
+ * Description: provide the encoded information for objectives
+ *
+ * Author Create/Modi Note
+ * Xiaofeng Xie Feb 10, 2004
+ *
+ * This library is free software; you can redistribute it and/or
+ * modify it under the terms of the GNU Lesser General Public
+ * License as published by the Free Software Foundation; either
+ * version 2.1 of the License, or (at your option) any later version.
+ *
+ * This library is distributed in the hope that it will be useful,
+ * but WITHOUT ANY WARRANTY; without even the implied warranty of
+ * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU
+ * Lesser General Public License for more details.
+ *
+ * Please acknowledge the author(s) if you use this code in any way.
+ */
+
+package net.adaptivebox.encode;
+
+public interface IEncodeEngine {
+ double[] getEncodeInfo();
+}
diff --git a/nlpsolver/ThirdParty/EvolutionarySolver/src/net/adaptivebox/global/BasicBound.java b/nlpsolver/ThirdParty/EvolutionarySolver/src/net/adaptivebox/global/BasicBound.java
new file mode 100644
index 000000000..6ed1089d9
--- /dev/null
+++ b/nlpsolver/ThirdParty/EvolutionarySolver/src/net/adaptivebox/global/BasicBound.java
@@ -0,0 +1,64 @@
+/**
+ * Description: provide a bound, and the corresponding operations
+ *
+ * Author Create/Modi Note
+ * Xiaofeng Xie Oct. 9, 2002
+ *
+ * This library is free software; you can redistribute it and/or
+ * modify it under the terms of the GNU Lesser General Public
+ * License as published by the Free Software Foundation; either
+ * version 2.1 of the License, or (at your option) any later version.
+ *
+ * This library is distributed in the hope that it will be useful,
+ * but WITHOUT ANY WARRANTY; without even the implied warranty of
+ * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU
+ * Lesser General Public License for more details.
+ *
+ * Please acknowledge the author(s) if you use this code in any way.
+ */
+
+package net.adaptivebox.global;
+
+public class BasicBound {
+ public static final double MINDOUBLE = -1e308;
+ public static final double MAXDOUBLE = 1e308;
+
+ public double minValue = MINDOUBLE;
+ public double maxValue = MAXDOUBLE;
+
+ public BasicBound() {
+ }
+
+ public BasicBound(double min, double max) {
+ minValue = Math.min(min, max);
+ maxValue = Math.max(min, max);
+ }
+
+ public double getLength() {
+ return Math.abs(maxValue - minValue);
+ }
+
+ public double boundAdjust(double value) {
+ if (value > maxValue) {
+ value = maxValue;
+ } else if (value < minValue) {
+ value = minValue;
+ }
+ return value;
+ }
+
+ public double annulusAdjust(double value) {
+ if (value > maxValue) {
+ double extendsLen = (value - maxValue) % getLength();
+ value = minValue + extendsLen;
+ } else if (value < minValue) {
+ double extendsLen = (minValue - value) % getLength();
+ value = maxValue - extendsLen;
+ }
+ return value;
+ }
+
+ public double getRandomValue() {
+ return RandomGenerator.doubleRangeRandom(minValue, maxValue);
+ }
+}
diff --git a/nlpsolver/ThirdParty/EvolutionarySolver/src/net/adaptivebox/global/IUpdateCycleEngine.java b/nlpsolver/ThirdParty/EvolutionarySolver/src/net/adaptivebox/global/IUpdateCycleEngine.java
new file mode 100644
index 000000000..0b4db684f
--- /dev/null
+++ b/nlpsolver/ThirdParty/EvolutionarySolver/src/net/adaptivebox/global/IUpdateCycleEngine.java
@@ -0,0 +1,24 @@
+/**
+ * Description: provide the interface for updating according to the cycle number
+ *
+ * Author Create/Modi Note
+ * Xiaofeng Xie Feb 18, 2004
+ *
+ * This library is free software; you can redistribute it and/or
+ * modify it under the terms of the GNU Lesser General Public
+ * License as published by the Free Software Foundation; either
+ * version 2.1 of the License, or (at your option) any later version.
+ *
+ * This library is distributed in the hope that it will be useful,
+ * but WITHOUT ANY WARRANTY; without even the implied warranty of
+ * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU
+ * Lesser General Public License for more details.
+ *
+ * Please acknowledge the author(s) if you use this code in any way.
+ */
+
+package net.adaptivebox.global;
+
+public interface IUpdateCycleEngine {
+ void updateCycle(int t);
+} \ No newline at end of file
diff --git a/nlpsolver/ThirdParty/EvolutionarySolver/src/net/adaptivebox/global/RandomGenerator.java b/nlpsolver/ThirdParty/EvolutionarySolver/src/net/adaptivebox/global/RandomGenerator.java
new file mode 100644
index 000000000..245149e87
--- /dev/null
+++ b/nlpsolver/ThirdParty/EvolutionarySolver/src/net/adaptivebox/global/RandomGenerator.java
@@ -0,0 +1,108 @@
+/**
+ * Description: For generating random numbers.
+ *
+ * Author Create/Modi Note
+ * Xiaofeng Xie Feb 22, 2001
+ *
+ * This library is free software; you can redistribute it and/or
+ * modify it under the terms of the GNU Lesser General Public
+ * License as published by the Free Software Foundation; either
+ * version 2.1 of the License, or (at your option) any later version.
+ *
+ * This library is distributed in the hope that it will be useful,
+ * but WITHOUT ANY WARRANTY; without even the implied warranty of
+ * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU
+ * Lesser General Public License for more details.
+ *
+ * Please acknowledge the author(s) if you use this code in any way.
+ *
+ * @version 1.0
+ * @Since MAOS1.0
+ */
+
+package net.adaptivebox.global;
+
+import java.util.Random;
+import java.security.SecureRandom;
+
+public class RandomGenerator {
+ /**
+ * Pseudo-random number generator instance.
+ */
+ private static Random PRNG = new Random();
+
+ /**
+ * Switch between weaker, but faster pseudo-random number generator and
+ * stronger, but slower.
+ *
+ * @param stronger activation of secure pseudo random generator flag
+ */
+ public static void useStrongerGenerator(boolean stronger) {
+ if(stronger == true) {
+ PRNG = new SecureRandom();
+ } else {
+ PRNG = new Random();
+ }
+ }
+
+ /**
+ * This function returns a random integer number between the lowLimit and
+ * upLimit.
+ *
+ * @param lowLimit lower limits upLimit The upper limits (between which the
+ * random number is to be generated)
+ * @return int return value Example: for find [0,1,2]
+ */
+ public static int intRangeRandom(int lowLimit, int upLimit) {
+ int num = lowLimit + PRNG.nextInt(upLimit - lowLimit + 1);
+ return num;
+ }
+
+ /**
+ * This function returns a random float number between the lowLimit and upLimit.
+ *
+ * @param lowLimit lower limits upLimit The upper limits (between which the
+ * random number is to be generated)
+ * @return double return value
+ */
+ public static double doubleRangeRandom(double lowLimit, double upLimit) {
+ double num = lowLimit + PRNG.nextDouble() * (upLimit - lowLimit);
+ return num;
+ }
+
+ /**
+ * This function returns a random float number between the zero (inclusive) and one (exclusive).
+ *
+ * @return double value in the range [0, 1)
+ */
+ public static double doubleZeroOneRandom() {
+ return PRNG.nextDouble();
+ }
+
+ public static int[] randomSelection(int maxNum, int times) {
+ if (maxNum < 0) {
+ maxNum = 0;
+ }
+
+ if (times < 0) {
+ times = 0;
+ }
+
+ int[] all = new int[maxNum];
+ for (int i = 0; i < all.length; i++) {
+ all[i] = i;
+ }
+
+ /* https://en.wikipedia.org/wiki/Fisher%E2%80%93Yates_shuffle */
+ int[] indices = new int[Math.min(maxNum, times)];
+ for (int i = 0, j, value; i < indices.length; i++) {
+ j = intRangeRandom(i, all.length - 1);
+
+ value = all[j];
+ all[j] = all[i];
+ indices[i] = all[i] = value;
+ }
+
+ return indices;
+ }
+}
diff --git a/nlpsolver/ThirdParty/EvolutionarySolver/src/net/adaptivebox/goodness/ACRComparator.java b/nlpsolver/ThirdParty/EvolutionarySolver/src/net/adaptivebox/goodness/ACRComparator.java
new file mode 100644
index 000000000..284549506
--- /dev/null
+++ b/nlpsolver/ThirdParty/EvolutionarySolver/src/net/adaptivebox/goodness/ACRComparator.java
@@ -0,0 +1,91 @@
+/**
+ * Description: For comparison of goodness in landscape with loosed constraints
+ * which varied adaptively according to the social information.
+ *
+ * Applied domain: efficiently for ridge class feasible space (SF), such as
+ * the problem with equality constraints
+ *
+ * Author Create/Modi Note
+ * Xiaofeng Xie Jun 24, 2003 Created
+ * Xiaofeng Xie May 11, 2004
+ *
+ * This library is free software; you can redistribute it and/or
+ * modify it under the terms of the GNU Lesser General Public
+ * License as published by the Free Software Foundation; either
+ * version 2.1 of the License, or (at your option) any later version.
+ *
+ * This library is distributed in the hope that it will be useful,
+ * but WITHOUT ANY WARRANTY; without even the implied warranty of
+ * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU
+ * Lesser General Public License for more details.
+ *
+ * Please acknowledge the author(s) if you use this code in any way.
+ *
+ * @version 1.0
+ * @Since MAOS1.2
+ *
+ * [1] Xie X F, Zhang W J, Bi D C. Handling equality constraints by adaptive
+ * relaxing rule for swarm algorithms. Congress on Evolutionary Computation,
+ * Oregon, USA, 2004
+ */
+
+package net.adaptivebox.goodness;
+
+import net.adaptivebox.global.IUpdateCycleEngine;
+import net.adaptivebox.knowledge.Library;
+
+public class ACRComparator implements IGoodnessCompareEngine, IUpdateCycleEngine {
+ private final Library socialPool;
+ private double epsilon_t = 0;
+
+ private static final double RU = 0.75;
+ private static final double RL = 0.25;
+ private static final double BETAF = 0.618;
+ private static final double BETAL = 0.618;
+ private static final double BETAU = 1.382;
+
+ private final double T;
+
+ private static final double TthR = 0.5;
+
+ public ACRComparator(Library lib, int T) {
+ socialPool = lib;
+ this.T = T;
+
+ // set the (epsilon_t|t=0) as the maximum CONS value among the SearchPoints in the library
+ epsilon_t = lib.getExtremalVcon(true);
+ }
+
+ private static int compare(double data1, double data2) {
+ if (data1 < data2)
+ return LESS_THAN;
+ else if (data1 > data2)
+ return LARGER_THAN;
+ else
+ return EQUAL_TO;
+ }
+
+ public int compare(double[] fit1, double[] fit2) {
+ if (Math.max(fit1[0], fit2[0]) <= Math.max(0, epsilon_t)) { // epsilon>0
+ return compare(fit1[1], fit2[1]);
+ } else {
+ return compare(fit1[0], fit2[0]);
+ }
+ }
+
+ public void updateCycle(int t) {
+ // calculates the ratio
+ double rn = (double) socialPool.getVconThanNum(epsilon_t) / (double) socialPool.getPopSize();
+
+ if (t > TthR * T && T != -1) { // Forcing sub-rule
+ epsilon_t *= BETAF;
+ } else { // Ratio-keeping sub-rules
+ if (rn > RU) {
+ epsilon_t *= BETAL; // Shrink
+ }
+ if (rn < RL) {
+ epsilon_t *= BETAU; // Relax
+ }
+ }
+ }
+}
diff --git a/nlpsolver/ThirdParty/EvolutionarySolver/src/net/adaptivebox/goodness/BCHComparator.java b/nlpsolver/ThirdParty/EvolutionarySolver/src/net/adaptivebox/goodness/BCHComparator.java
new file mode 100644
index 000000000..8140650dd
--- /dev/null
+++ b/nlpsolver/ThirdParty/EvolutionarySolver/src/net/adaptivebox/goodness/BCHComparator.java
@@ -0,0 +1,46 @@
+/**
+ * Description: For formation the basic goodness landscape.
+ *
+ * Author Create/Modi Note
+ * Xiaofeng Xie Jun 24, 2003 Created
+ * Xiaofeng Xie May 11, 2004
+ *
+ * This library is free software; you can redistribute it and/or
+ * modify it under the terms of the GNU Lesser General Public
+ * License as published by the Free Software Foundation; either
+ * version 2.1 of the License, or (at your option) any later version.
+ *
+ * This library is distributed in the hope that it will be useful,
+ * but WITHOUT ANY WARRANTY; without even the implied warranty of
+ * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU
+ * Lesser General Public License for more details.
+ *
+ * Please acknowledge the author(s) if you use this code in any way.
+ *
+ * @version 1.0
+ * @Since MAOS1.2
+ *
+ * [1] Deb K. An efficient constraint handling method for genetic algorithms.
+ * Computer Methods in Applied Mechanics and Engineering, 2000, 186(2-4): 311-338
+ */
+
+package net.adaptivebox.goodness;
+
+public class BCHComparator implements IGoodnessCompareEngine {
+
+ /* check the magnitude of two array, the frontal is more important */
+ private static int compareArray(double[] fit1, double[] fit2) {
+ for (int i = 0; i < fit1.length; i++) {
+ if (fit1[i] > fit2[i]) {
+ return LARGER_THAN; // Large than
+ } else if (fit1[i] < fit2[i]) {
+ return LESS_THAN; // Less than
+ }
+ }
+ return IGoodnessCompareEngine.EQUAL_TO; // same
+ }
+
+ public int compare(double[] fit1, double[] fit2) {
+ return compareArray(fit1, fit2);
+ }
+}
diff --git a/nlpsolver/ThirdParty/EvolutionarySolver/src/net/adaptivebox/goodness/IGoodnessCompareEngine.java b/nlpsolver/ThirdParty/EvolutionarySolver/src/net/adaptivebox/goodness/IGoodnessCompareEngine.java
new file mode 100644
index 000000000..17a85993d
--- /dev/null
+++ b/nlpsolver/ThirdParty/EvolutionarySolver/src/net/adaptivebox/goodness/IGoodnessCompareEngine.java
@@ -0,0 +1,41 @@
+/**
+ * Description: For comparison of goodness.
+ *
+ * Author Create/Modi Note
+ * Xiaofeng Xie Feb 19, 2004
+ * Xiaofeng Xie May 11, 2004
+ *
+ * This library is free software; you can redistribute it and/or
+ * modify it under the terms of the GNU Lesser General Public
+ * License as published by the Free Software Foundation; either
+ * version 2.1 of the License, or (at your option) any later version.
+ *
+ * This library is distributed in the hope that it will be useful,
+ * but WITHOUT ANY WARRANTY; without even the implied warranty of
+ * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU
+ * Lesser General Public License for more details.
+ *
+ * Please acknowledge the author(s) if you use this code in any way.
+ *
+ * @version 1.0
+ * @Since MAOS1.2
+ */
+
+package net.adaptivebox.goodness;
+
+public abstract interface IGoodnessCompareEngine {
+ int LARGER_THAN = 2;
+ int EQUAL_TO = 1;
+ int LESS_THAN = 0;
+
+ /**
+ * check the magnitude of two IEncodeEngine
+ *
+ * LARGER_THAN: goodness1 is worse than goodness2
+ *
+ * LESS_THAN: goodness1 is better than goodness2
+ *
+ * EQUAL_TO : goodness1 is equal to goodness2
+ */
+ int compare(double[] goodness1, double[] goodness2);
+}
diff --git a/nlpsolver/ThirdParty/EvolutionarySolver/src/net/adaptivebox/knowledge/ILibEngine.java b/nlpsolver/ThirdParty/EvolutionarySolver/src/net/adaptivebox/knowledge/ILibEngine.java
new file mode 100644
index 000000000..b4787c30c
--- /dev/null
+++ b/nlpsolver/ThirdParty/EvolutionarySolver/src/net/adaptivebox/knowledge/ILibEngine.java
@@ -0,0 +1,27 @@
+
+/**
+ * Description: set the library.
+ *
+ * Author Create/Modi Note
+ * Xiaofeng Xie May 14, 2004
+ *
+ * This library is free software; you can redistribute it and/or
+ * modify it under the terms of the GNU Lesser General Public
+ * License as published by the Free Software Foundation; either
+ * version 2.1 of the License, or (at your option) any later version.
+ *
+ * This library is distributed in the hope that it will be useful,
+ * but WITHOUT ANY WARRANTY; without even the implied warranty of
+ * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU
+ * Lesser General Public License for more details.
+ *
+ * Please acknowledge the author(s) if you use this code in any way.
+ *
+ * @version 1.1
+ * @Since MAOS1.0
+ */
+package net.adaptivebox.knowledge;
+
+public interface ILibEngine {
+ void setLibrary(Library lib);
+}
diff --git a/nlpsolver/ThirdParty/EvolutionarySolver/src/net/adaptivebox/knowledge/Library.java b/nlpsolver/ThirdParty/EvolutionarySolver/src/net/adaptivebox/knowledge/Library.java
new file mode 100644
index 000000000..76e57ac76
--- /dev/null
+++ b/nlpsolver/ThirdParty/EvolutionarySolver/src/net/adaptivebox/knowledge/Library.java
@@ -0,0 +1,106 @@
+
+/**
+ * Description: Contains a set of points.
+ *
+ * Author Create/Modi Note
+ * Xiaofeng Xie Mar 7, 2003
+ * Xiaofeng Xie May 3, 2003
+ * Xiaofeng Xie May 11, 2004
+ *
+ * This library is free software; you can redistribute it and/or
+ * modify it under the terms of the GNU Lesser General Public
+ * License as published by the Free Software Foundation; either
+ * version 2.1 of the License, or (at your option) any later version.
+ *
+ * This library is distributed in the hope that it will be useful,
+ * but WITHOUT ANY WARRANTY; without even the implied warranty of
+ * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU
+ * Lesser General Public License for more details.
+ *
+ * Please acknowledge the author(s) if you use this code in any way.
+ *
+ * @version 1.1
+ * @Since MAOS1.0
+ */
+package net.adaptivebox.knowledge;
+
+import net.adaptivebox.global.BasicBound;
+import net.adaptivebox.global.RandomGenerator;
+import net.adaptivebox.goodness.IGoodnessCompareEngine;
+import net.adaptivebox.problem.ProblemEncoder;
+
+public class Library {
+ private final SearchPoint[] libPoints;
+ private int gIndex = -1;
+
+ public Library(int number, ProblemEncoder problemEncoder) {
+ libPoints = new SearchPoint[number];
+ for (int i = 0; i < number; i++) {
+ libPoints[i] = problemEncoder.getEncodedSearchPoint();
+ }
+ }
+
+ public SearchPoint getGbest() {
+ return getSelectedPoint(gIndex);
+ }
+
+ public void refreshGbest(IGoodnessCompareEngine qualityComparator) {
+ gIndex = tournamentSelection(qualityComparator, getPopSize() - 1, true);
+ }
+
+ public int getPopSize() {
+ return libPoints.length;
+ }
+
+ public SearchPoint getSelectedPoint(int index) {
+ return libPoints[index];
+ }
+
+ public SearchPoint getRandomPoint() {
+ return libPoints[RandomGenerator.intRangeRandom(0, libPoints.length - 1)];
+ }
+
+ public static boolean replace(IGoodnessCompareEngine comparator, SearchPoint outPoint,
+ SearchPoint tobeReplacedPoint) {
+ boolean isBetter = false;
+ if (comparator.compare(outPoint.getEncodeInfo(),
+ tobeReplacedPoint.getEncodeInfo()) < IGoodnessCompareEngine.LARGER_THAN) {
+ tobeReplacedPoint.importPoint(outPoint);
+ isBetter = true;
+ }
+ return isBetter;
+ }
+
+ public int tournamentSelection(IGoodnessCompareEngine comparator, int times, boolean isBetter) {
+ int[] indices = RandomGenerator.randomSelection(getPopSize(), times);
+ int currentIndex = indices[0];
+ for (int i = 1; i < indices.length; i++) {
+ int compareValue = comparator.compare(libPoints[indices[i]].getEncodeInfo(),
+ libPoints[currentIndex].getEncodeInfo());
+ if (isBetter == (compareValue < IGoodnessCompareEngine.LARGER_THAN)) {
+ currentIndex = indices[i];
+ }
+ }
+ return currentIndex;
+ }
+
+ public double getExtremalVcon(boolean isMAX) {
+ double val = BasicBound.MINDOUBLE;
+ for (int i = 0; i < libPoints.length; i++) {
+ if (libPoints[i].getEncodeInfo()[0] > val == isMAX) {
+ val = libPoints[i].getEncodeInfo()[0];
+ }
+ }
+ return val;
+ }
+
+ public int getVconThanNum(double allowedCons) {
+ int num = 0;
+ for (int i = 0; i < libPoints.length; i++) {
+ if (libPoints[i].getEncodeInfo()[0] <= allowedCons) {
+ num++;
+ }
+ }
+ return num;
+ }
+}
diff --git a/nlpsolver/ThirdParty/EvolutionarySolver/src/net/adaptivebox/knowledge/SearchPoint.java b/nlpsolver/ThirdParty/EvolutionarySolver/src/net/adaptivebox/knowledge/SearchPoint.java
new file mode 100644
index 000000000..df13efc74
--- /dev/null
+++ b/nlpsolver/ThirdParty/EvolutionarySolver/src/net/adaptivebox/knowledge/SearchPoint.java
@@ -0,0 +1,70 @@
+/**
+ * Description: provide the location and encoded goodness information
+ *
+ * Author Create/Modi Note
+ * Xiaofeng Xie Mar 1, 2003
+ * Xiaofeng Xie May 11, 2004
+ *
+ * This library is free software; you can redistribute it and/or
+ * modify it under the terms of the GNU Lesser General Public
+ * License as published by the Free Software Foundation; either
+ * version 2.1 of the License, or (at your option) any later version.
+ *
+ * This library is distributed in the hope that it will be useful,
+ * but WITHOUT ANY WARRANTY; without even the implied warranty of
+ * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU
+ * Lesser General Public License for more details.
+ *
+ * Please acknowledge the author(s) if you use this code in any way.
+ */
+package net.adaptivebox.knowledge;
+
+import net.adaptivebox.encode.IEncodeEngine;
+import net.adaptivebox.global.BasicBound;
+import net.adaptivebox.space.BasicPoint;
+
+public class SearchPoint extends BasicPoint implements IEncodeEngine {
+ // store the encode information for goodness evaluation
+ // encodeInfo[0]: the sum of constraints (if it equals to 0, then be a feasible point)
+ // encodeInfo[1]: the value of objective function
+ private final double[] encodeInfo = new double[2];
+ private double objectiveValue;
+
+ public SearchPoint(int dim) {
+ super(dim);
+ for (int i = 0; i < encodeInfo.length; i++) {
+ encodeInfo[i] = BasicBound.MAXDOUBLE;
+ }
+ }
+
+ public double[] getEncodeInfo() {
+ return encodeInfo;
+ }
+
+ private void importEncodeInfo(double[] info) {
+ System.arraycopy(info, 0, encodeInfo, 0, encodeInfo.length);
+ }
+
+ private void importEncodeInfo(IEncodeEngine point) {
+ importEncodeInfo(point.getEncodeInfo());
+ }
+
+ // Replace self by given point
+ public void importPoint(SearchPoint point) {
+ importLocation(point);
+ importEncodeInfo(point);
+ setObjectiveValue(point.getObjectiveValue());
+ }
+
+ public double getObjectiveValue() {
+ return objectiveValue;
+ }
+
+ public void setObjectiveValue(double objectiveValue) {
+ this.objectiveValue = objectiveValue;
+ }
+
+ public boolean isFeasible() {
+ return encodeInfo[0] == 0; // no constraint violations
+ }
+}
diff --git a/nlpsolver/ThirdParty/EvolutionarySolver/src/net/adaptivebox/problem/ProblemEncoder.java b/nlpsolver/ThirdParty/EvolutionarySolver/src/net/adaptivebox/problem/ProblemEncoder.java
new file mode 100644
index 000000000..674d27542
--- /dev/null
+++ b/nlpsolver/ThirdParty/EvolutionarySolver/src/net/adaptivebox/problem/ProblemEncoder.java
@@ -0,0 +1,109 @@
+/**
+ * Description: Encodes the specified problem into encoded information for
+ * forming the goodness landscape.
+ *
+ * Author Create/Modi Note
+ * Xiaofeng Xie May 31, 2000
+ * Xiaofeng Xie Sep. 19, 2002
+ * Xiaofeng Xie Mar. 01, 2003
+ * Xiaofeng Xie May 11, 2004
+ *
+ * This library is free software; you can redistribute it and/or
+ * modify it under the terms of the GNU Lesser General Public
+ * License as published by the Free Software Foundation; either
+ * version 2.1 of the License, or (at your option) any later version.
+ *
+ * This library is distributed in the hope that it will be useful,
+ * but WITHOUT ANY WARRANTY; without even the implied warranty of
+ * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU
+ * Lesser General Public License for more details.
+ *
+ * Please acknowledge the author(s) if you use this code in any way.
+ *
+ * @version 1.0
+ * @Since MAOS1.0
+ */
+
+package net.adaptivebox.problem;
+
+import net.adaptivebox.encode.EvalElement;
+import net.adaptivebox.encode.EvalStruct;
+import net.adaptivebox.global.BasicBound;
+import net.adaptivebox.knowledge.SearchPoint;
+import net.adaptivebox.space.DesignDim;
+import net.adaptivebox.space.DesignSpace;
+
+public abstract class ProblemEncoder {
+ // Store the calculated results for the responses
+ private final double[] tempResponseSet; // temp values
+ private final double[] tempLocation; // temp values
+
+ // the search space (S)
+ private final DesignSpace designSpace;
+
+ // For evaluate the response vector into encoded vector double[2]
+ private final EvalStruct evalStruct;
+
+ protected ProblemEncoder(int paramNum, int targetNum) throws Exception {
+ designSpace = new DesignSpace(paramNum);
+ evalStruct = new EvalStruct(targetNum);
+ tempLocation = new double[paramNum];
+ tempResponseSet = new double[targetNum];
+ }
+
+ public DesignSpace getDesignSpace() {
+ return designSpace;
+ }
+
+ // set the default information for each dimension of search space (S)
+ protected void setDefaultXAt(int i, double min, double max, double grain) {
+ DesignDim dd = new DesignDim();
+ dd.grain = grain;
+ dd.paramBound = new BasicBound(min, max);
+ designSpace.setElemAt(dd, i);
+ }
+
+ // set the default information for evaluation each response
+ protected void setDefaultYAt(int i, double min, double max) {
+ EvalElement ee = new EvalElement();
+ ee.targetBound = new BasicBound(min, max);
+ evalStruct.setElemAt(ee, i);
+ }
+
+ // get a fresh point
+ public SearchPoint getFreshSearchPoint() {
+ return new SearchPoint(designSpace.getDimension());
+ }
+
+ // get an encoded point
+ public SearchPoint getEncodedSearchPoint() {
+ SearchPoint point = getFreshSearchPoint();
+ designSpace.initializeGene(point.getLocation());
+ evaluate(point);
+ return point;
+ }
+
+ // evaluate the point into encoded information
+ public void evaluate(SearchPoint point) {
+ // copy to temp point
+ System.arraycopy(point.getLocation(), 0, this.tempLocation, 0, tempLocation.length);
+
+ // mapping the temp point to original search space S
+ designSpace.getMappingPoint(tempLocation);
+
+ // calculate based on the temp point
+ calcTargets(tempResponseSet, tempLocation);
+ evalStruct.evaluate(point.getEncodeInfo(), tempResponseSet);
+ point.setObjectiveValue(tempResponseSet[0]);
+ }
+
+ // calculate each response, must be implemented
+ abstract protected double calcTargetAt(int index, double[] VX);
+
+ // calculate all the responses VY[] based on given point VX[]
+ private void calcTargets(double[] VY, double[] VX) {
+ for (int i = 0; i < VY.length; i++) {
+ VY[i] = calcTargetAt(i, VX);
+ }
+ }
+}
diff --git a/nlpsolver/ThirdParty/EvolutionarySolver/src/net/adaptivebox/sco/SCAgent.java b/nlpsolver/ThirdParty/EvolutionarySolver/src/net/adaptivebox/sco/SCAgent.java
new file mode 100644
index 000000000..a09d0dcfd
--- /dev/null
+++ b/nlpsolver/ThirdParty/EvolutionarySolver/src/net/adaptivebox/sco/SCAgent.java
@@ -0,0 +1,143 @@
+package net.adaptivebox.sco;
+
+/**
+ * Description: The description of social cognitive agent.
+ *
+ * @Information source: a) external library (L); b) the own memory: a point that
+ * generated in the last learning cycle
+ *
+ * @Coefficients: TaoB and TaoW
+ *
+ * @ Author Create/Modi Note
+ * Xiaofeng Xie Mar 11, 2003
+ * Xiaofeng Xie May 11, 2004
+ * Xiaofeng Xie May 20, 2004
+ *
+ * This library is free software; you can redistribute it and/or
+ * modify it under the terms of the GNU Lesser General Public
+ * License as published by the Free Software Foundation; either
+ * version 2.1 of the License, or (at your option) any later version.
+ *
+ * This library is distributed in the hope that it will be useful,
+ * but WITHOUT ANY WARRANTY; without even the implied warranty of
+ * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU
+ * Lesser General Public License for more details.
+ *
+ * Please acknowledge the author(s) if you use this code in any way.
+ *
+ * @version 1.0
+ * @Since MAOS1.0
+ *
+ * @References:
+ * [1] Xie X F, Zhang W J. Solving engineering design problems by social cognitive
+ * optimization. Genetic and Evolutionary Computation Conference, 2004: 261-262
+ */
+
+import net.adaptivebox.problem.ProblemEncoder;
+import net.adaptivebox.space.DesignSpace;
+import net.adaptivebox.space.ILocationEngine;
+import net.adaptivebox.global.RandomGenerator;
+import net.adaptivebox.goodness.IGoodnessCompareEngine;
+import net.adaptivebox.knowledge.Library;
+import net.adaptivebox.knowledge.SearchPoint;
+
+public class SCAgent {
+
+ // Describes the problem to be solved (encode the point into intermediate information)
+ private ProblemEncoder problemEncoder;
+
+ // Forms the goodness landscape
+ private IGoodnessCompareEngine specComparator;
+
+ // the coefficients of SCAgent
+ private static final int TaoB = 2;
+
+ // The early version set TaoW as the size of external library (NL), but 4 is often enough
+ private static final int TaoW = 4;
+
+ // The referred external library
+ private Library externalLib;
+
+ // store the point that generated in current learning cycle
+ private SearchPoint trailPoint;
+
+ // the own memory: store the point that generated in last learning cycle
+ private SearchPoint pcurrent_t;
+
+ public void setExternalLib(Library lib) {
+ externalLib = lib;
+ }
+
+ public void setProblemEncoder(ProblemEncoder encoder) {
+ problemEncoder = encoder;
+ trailPoint = problemEncoder.getFreshSearchPoint();
+ pcurrent_t = problemEncoder.getEncodedSearchPoint();
+ }
+
+ public void setSpecComparator(IGoodnessCompareEngine comparer) {
+ specComparator = comparer;
+ }
+
+ public SearchPoint generatePoint() {
+ // generate a new point
+ generatePoint(trailPoint);
+
+ // evaluate the generated point
+ problemEncoder.evaluate(trailPoint);
+ return trailPoint;
+ }
+
+ private void generatePoint(ILocationEngine tempPoint) {
+ SearchPoint Xmodel, Xrefer, libBPoint;
+
+ // choose Selects a better point (libBPoint) from externalLib (L) based
+ // on tournament selection
+ int xb = externalLib.tournamentSelection(specComparator, TaoB, true);
+ libBPoint = externalLib.getSelectedPoint(xb);
+
+ // Compares pcurrent_t with libBPoint
+ // The better one becomes model point (Xmodel)
+ // The worse one becomes refer point (Xrefer)
+ if (specComparator.compare(pcurrent_t.getEncodeInfo(),
+ libBPoint.getEncodeInfo()) == IGoodnessCompareEngine.LARGER_THAN) {
+ Xmodel = libBPoint;
+ Xrefer = pcurrent_t;
+ } else {
+ Xmodel = pcurrent_t;
+ Xrefer = libBPoint;
+ }
+
+ // observational learning: generates a new point near the model point, which
+ // the variation range is decided by the difference of Xmodel and Xrefer
+ inferPoint(tempPoint, Xmodel, Xrefer, problemEncoder.getDesignSpace());
+ }
+
+ // 1. Update the current point into the external library
+ // 2. Replace the current point by the generated point
+ public void updateInfo() {
+ // Selects a bad point kw from TaoW points in Library
+ int xw = externalLib.tournamentSelection(specComparator, TaoW, false);
+
+ // Replaces kw with pcurrent_t
+ externalLib.getSelectedPoint(xw).importPoint(pcurrent_t);
+
+ // Replaces pcurrent_t (x(t)) with trailPoint (x(t+1))
+ pcurrent_t.importPoint(trailPoint);
+ }
+
+ // 1---model point, 2---refer point
+ private boolean inferPoint(ILocationEngine newPoint, ILocationEngine point1, ILocationEngine point2,
+ DesignSpace space) {
+ double[] newLoc = newPoint.getLocation();
+ double[] real1 = point1.getLocation();
+ double[] real2 = point2.getLocation();
+
+ for (int i = 0; i < newLoc.length; i++) {
+ newLoc[i] = real1[i] * 2 - real2[i];
+ // boundary handling
+ newLoc[i] = space.boundAdjustAt(newLoc[i], i);
+ newLoc[i] = RandomGenerator.doubleRangeRandom(newLoc[i], real2[i]);
+ }
+ return true;
+ }
+}
diff --git a/nlpsolver/ThirdParty/EvolutionarySolver/src/net/adaptivebox/space/BasicPoint.java b/nlpsolver/ThirdParty/EvolutionarySolver/src/net/adaptivebox/space/BasicPoint.java
new file mode 100644
index 000000000..9f6c2ec01
--- /dev/null
+++ b/nlpsolver/ThirdParty/EvolutionarySolver/src/net/adaptivebox/space/BasicPoint.java
@@ -0,0 +1,42 @@
+/**
+ * Description: provide the location information of a point
+ *
+ * Author Create/Modi Note
+ * Xiaofeng Xie Mar 1, 2003
+ * Xiaofeng Xie May 11, 2004
+ *
+ * This library is free software; you can redistribute it and/or
+ * modify it under the terms of the GNU Lesser General Public
+ * License as published by the Free Software Foundation; either
+ * version 2.1 of the License, or (at your option) any later version.
+ *
+ * This library is distributed in the hope that it will be useful,
+ * but WITHOUT ANY WARRANTY; without even the implied warranty of
+ * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU
+ * Lesser General Public License for more details.
+ *
+ * Please acknowledge the author(s) if you use this code in any way.
+ */
+
+package net.adaptivebox.space;
+
+public class BasicPoint implements ILocationEngine {
+ // store the location information in the search space (S)
+ private final double[] location;
+
+ public BasicPoint(int dim) {
+ location = new double[dim];
+ }
+
+ public double[] getLocation() {
+ return location;
+ }
+
+ public void importLocation(double[] pointLoc) {
+ System.arraycopy(pointLoc, 0, location, 0, pointLoc.length);
+ }
+
+ public void importLocation(ILocationEngine point) {
+ importLocation(point.getLocation());
+ }
+} \ No newline at end of file
diff --git a/nlpsolver/ThirdParty/EvolutionarySolver/src/net/adaptivebox/space/DesignDim.java b/nlpsolver/ThirdParty/EvolutionarySolver/src/net/adaptivebox/space/DesignDim.java
new file mode 100644
index 000000000..f8f283bf1
--- /dev/null
+++ b/nlpsolver/ThirdParty/EvolutionarySolver/src/net/adaptivebox/space/DesignDim.java
@@ -0,0 +1,45 @@
+/**
+ * Description: provide the information for goodness evaluation of a target
+ *
+ * Author Create/Modi Note
+ * Xiaofeng Xie Mar 1, 2003
+ * Xiaofeng Xie May 3, 2004 Add grain value
+ * Xiaofeng Xie May 11, 2004 Add crowd distance
+ *
+ * This library is free software; you can redistribute it and/or
+ * modify it under the terms of the GNU Lesser General Public
+ * License as published by the Free Software Foundation; either
+ * version 2.1 of the License, or (at your option) any later version.
+ *
+ * This library is distributed in the hope that it will be useful,
+ * but WITHOUT ANY WARRANTY; without even the implied warranty of
+ * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU
+ * Lesser General Public License for more details.
+ *
+ * Please acknowledge the author(s) if you use this code in any way.
+ */
+
+package net.adaptivebox.space;
+
+import net.adaptivebox.global.BasicBound;
+
+public class DesignDim {
+ // To discrete space with the given step. For example, for an integer variable,
+ // The grain value can be set as 1.
+ public double grain = 0;
+ public BasicBound paramBound = new BasicBound(); // the range of a parameter
+
+ public boolean isDiscrete() {
+ return grain != 0;
+ }
+
+ public double getGrainedValue(double value) {
+ if (grain == 0) {
+ return value;
+ } else if (grain > 0) {
+ return paramBound.minValue + Math.rint((value - paramBound.minValue) / grain) * grain;
+ } else {
+ return paramBound.maxValue - Math.rint((paramBound.maxValue - value) / grain) * grain;
+ }
+ }
+}
diff --git a/nlpsolver/ThirdParty/EvolutionarySolver/src/net/adaptivebox/space/DesignSpace.java b/nlpsolver/ThirdParty/EvolutionarySolver/src/net/adaptivebox/space/DesignSpace.java
new file mode 100644
index 000000000..7d9307936
--- /dev/null
+++ b/nlpsolver/ThirdParty/EvolutionarySolver/src/net/adaptivebox/space/DesignSpace.java
@@ -0,0 +1,73 @@
+/**
+ * Description: provide the information for the search space (S)
+ *
+ * Author Create/Modi Note
+ * Xiaofeng Xie Mar 2, 2003
+ * Xiaofeng Xie May 11, 2004
+ *
+ * This library is free software; you can redistribute it and/or
+ * modify it under the terms of the GNU Lesser General Public
+ * License as published by the Free Software Foundation; either
+ * version 2.1 of the License, or (at your option) any later version.
+ *
+ * This library is distributed in the hope that it will be useful,
+ * but WITHOUT ANY WARRANTY; without even the implied warranty of
+ * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU
+ * Lesser General Public License for more details.
+ *
+ * Please acknowledge the author(s) if you use this code in any way.
+ *
+ * @References:
+ * [1] Zhang W J, Xie X F, Bi D C. Handling boundary constraints for numerical
+ * optimization by particle swarm flying in periodic search space. Congress
+ * on Evolutionary Computation, Oregon, USA, 2004
+ * especially for particle swarm agent
+ */
+
+package net.adaptivebox.space;
+
+public class DesignSpace {
+ // The information of all the dimension
+ private DesignDim[] dimProps;
+
+ public DesignSpace(int dim) {
+ dimProps = new DesignDim[dim];
+ }
+
+ public void setElemAt(DesignDim elem, int index) {
+ dimProps[index] = elem;
+ }
+
+ public int getDimension() {
+ if (dimProps == null) {
+ return -1;
+ }
+ return dimProps.length;
+ }
+
+ public double boundAdjustAt(double val, int dim) {
+ return dimProps[dim].paramBound.boundAdjust(val);
+ }
+
+ public void mutationAt(double[] location, int i) {
+ location[i] = dimProps[i].paramBound.getRandomValue();
+ }
+
+ public double getMagnitudeIn(int dimensionIndex) {
+ return dimProps[dimensionIndex].paramBound.getLength();
+ }
+
+ public void initializeGene(double[] tempX) {
+ for (int i = 0; i < tempX.length; i++)
+ tempX[i] = dimProps[i].paramBound.getRandomValue(); // Global.RandomGenerator.doubleRangeRandom(9.8, 10);
+ }
+
+ public void getMappingPoint(double[] point) {
+ for (int i = 0; i < getDimension(); i++) {
+ point[i] = dimProps[i].paramBound.annulusAdjust(point[i]);
+ if (dimProps[i].isDiscrete()) {
+ point[i] = dimProps[i].getGrainedValue(point[i]);
+ }
+ }
+ }
+}
diff --git a/nlpsolver/ThirdParty/EvolutionarySolver/src/net/adaptivebox/space/ILocationEngine.java b/nlpsolver/ThirdParty/EvolutionarySolver/src/net/adaptivebox/space/ILocationEngine.java
new file mode 100644
index 000000000..6b839df6e
--- /dev/null
+++ b/nlpsolver/ThirdParty/EvolutionarySolver/src/net/adaptivebox/space/ILocationEngine.java
@@ -0,0 +1,25 @@
+/**
+ * Description: provide the information for location
+ *
+ * Author Create/Modi Note
+ * Xiaofeng Xie May 3, 2003
+ * Xiaofeng Xie May 11, 2004
+ *
+ * This library is free software; you can redistribute it and/or
+ * modify it under the terms of the GNU Lesser General Public
+ * License as published by the Free Software Foundation; either
+ * version 2.1 of the License, or (at your option) any later version.
+ *
+ * This library is distributed in the hope that it will be useful,
+ * but WITHOUT ANY WARRANTY; without even the implied warranty of
+ * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU
+ * Lesser General Public License for more details.
+ *
+ * Please acknowledge the author(s) if you use this code in any way.
+ */
+
+package net.adaptivebox.space;
+
+public interface ILocationEngine {
+ double[] getLocation();
+}