git.gag.com Git - debian/openrocket/blob - core/src/net/sf/openrocket/utils/TestFunctionOptimizerLoop.java

   1 package net.sf.openrocket.utils;
   2
   3 import java.util.ArrayList;
   4 import java.util.List;
   5 import java.util.concurrent.ArrayBlockingQueue;
   6 import java.util.concurrent.ExecutorService;
   7 import java.util.concurrent.ThreadPoolExecutor;
   8 import java.util.concurrent.TimeUnit;
   9
  10 import net.sf.openrocket.optimization.general.Function;
  11 import net.sf.openrocket.optimization.general.FunctionOptimizer;
  12 import net.sf.openrocket.optimization.general.OptimizationController;
  13 import net.sf.openrocket.optimization.general.OptimizationException;
  14 import net.sf.openrocket.optimization.general.ParallelExecutorCache;
  15 import net.sf.openrocket.optimization.general.Point;
  16 import net.sf.openrocket.optimization.general.multidim.MultidirectionalSearchOptimizer;
  17 import net.sf.openrocket.util.MathUtil;
  18
  19
  20 public class TestFunctionOptimizerLoop {
  21
  22         private static final double PRECISION = 0.01;
  23
  24         private Point optimum;
  25         private int stepCount = 0;
  26         private int evaluations = 0;
  27
  28
  29
  30         private void go(final FunctionOptimizer optimizer, final Point optimum, final int maxSteps, ExecutorService executor) throws OptimizationException {
  31
  32                 Function function = new Function() {
  33                         @Override
  34                         public double evaluate(Point p) throws InterruptedException {
  35                                 evaluations++;
  36                                 return p.sub(optimum).length2();
  37                         }
  38                 };
  39
  40                 OptimizationController control = new OptimizationController() {
  41
  42                         @Override
  43                         public boolean stepTaken(Point oldPoint, double oldValue, Point newPoint, double newValue, double stepSize) {
  44                                 stepCount++;
  45                                 if (stepCount % 1000 == 0) {
  46                                         System.err.println("WARNING: Over " + stepCount + " steps required for optimum=" + optimum +
  47                                                                 " position=" + newPoint);
  48                                 }
  49                                 double distance = newPoint.sub(optimum).length();
  50                                 return distance >= PRECISION;
  51                         }
  52                 };
  53                 ;
  54
  55                 ParallelExecutorCache cache = new ParallelExecutorCache(executor);
  56                 cache.setFunction(function);
  57                 optimizer.setFunctionCache(cache);
  58                 optimizer.optimize(new Point(optimum.dim(), 0.5), control);
  59         }
  60
  61
  62         public static void main(String[] args) throws OptimizationException {
  63
  64                 System.err.println("PRECISION = " + PRECISION);
  65
  66                 ThreadPoolExecutor executor = new ThreadPoolExecutor(2, 2, 1, TimeUnit.SECONDS, new ArrayBlockingQueue<Runnable>(100));
  67
  68                 for (int dim = 1; dim <= 10; dim++) {
  69
  70                         List<Integer> stepCount = new ArrayList<Integer>();
  71                         List<Integer> functionCount = new ArrayList<Integer>();
  72
  73                         MultidirectionalSearchOptimizer optimizer = new MultidirectionalSearchOptimizer();
  74                         for (int count = 0; count < 200; count++) {
  75                                 TestFunctionOptimizerLoop test = new TestFunctionOptimizerLoop();
  76                                 double[] point = new double[dim];
  77                                 for (int i = 0; i < dim; i++) {
  78                                         point[i] = Math.random();
  79                                 }
  80                                 //                              point[0] = 0.7;
  81                                 test.go(optimizer, new Point(point), 20, executor);
  82                                 stepCount.add(test.stepCount);
  83                                 functionCount.add(test.evaluations);
  84                         }
  85
  86                         //                      System.err.println("StepCount = " + stepCount);
  87
  88                         System.out.printf("dim=%d  Steps avg=%5.2f dev=%5.2f median=%.1f  " +
  89                                         "Evaluations avg=%5.2f dev=%5.2f median=%.1f\n",
  90                                         dim, MathUtil.average(stepCount), MathUtil.stddev(stepCount), MathUtil.median(stepCount),
  91                                         MathUtil.average(functionCount), MathUtil.stddev(functionCount), MathUtil.median(functionCount));
  92                         System.out.println("stat: " + optimizer.getStatistics());
  93
  94                 }
  95
  96                 executor.shutdownNow();
  97         }
  98
  99
 100
 101 }