예제 #1
0
 @ScalarOperator(SATURATED_FLOOR_CAST)
 @SqlType(StandardTypes.INTEGER)
 public static long saturatedFloorCastToInteger(@SqlType(StandardTypes.DOUBLE) double value) {
   if (value <= MIN_INT_AS_DOUBLE) {
     return Integer.MIN_VALUE;
   }
   if (MAX_INT_AS_DOUBLE - value <= 1) {
     return Integer.MAX_VALUE;
   }
   return DoubleMath.roundToInt(value, FLOOR);
 }
예제 #2
0
  @Override
  public ExperimentResults compute(Builder builder, Set<SimArgs> inputs) {
    final IdMap<MASConfiguration> configMap = new IdMap<>("c", MASConfiguration.class);
    final IdMap<ScenarioProvider> scenarioMap = new IdMap<>("s", ScenarioProvider.class);
    final IdMap<ObjectiveFunction> objFuncMap = new IdMap<>("o", ObjectiveFunction.class);

    final List<ResultListener> listeners = newArrayList(builder.resultListeners);

    @SuppressWarnings({"rawtypes", "unchecked"})
    final IdMap<PostProcessor<?>> ppMap = new IdMap("p", PostProcessor.class);
    final Map<String, Scenario> scenariosMap = newLinkedHashMap();

    // create tasks
    final List<SimulationTask> tasks = newArrayList();
    constructTasks(inputs, tasks, configMap, scenarioMap, objFuncMap, ppMap, scenariosMap);

    // this sorts tasks using this chain: scenario, configuration, objective
    // function, postprocessor, seed
    Collections.sort(tasks);

    // determine size of batches
    final int numBatches = Math.min(tasks.size(), builder.numBatches);
    final int batchSize =
        DoubleMath.roundToInt(tasks.size() / (double) numBatches, RoundingMode.CEILING);

    final Map<Task<?>, JPPFJob> taskJobMap = newLinkedHashMap();
    final ResultsCollector res =
        new ResultsCollector(tasks.size(), scenariosMap, taskJobMap, listeners);
    final List<JPPFJob> jobs = newArrayList();

    for (int i = 0; i < numBatches; i++) {
      final JPPFJob job = new JPPFJob(new MemoryMapDataProvider(), res);
      job.setName(Joiner.on("").join(JOB_NAME, " ", i + 1, "/", numBatches));
      jobs.add(job);
      for (final SimulationTask t : tasks.subList(i * batchSize, (i + 1) * batchSize)) {
        try {
          final MASConfiguration config = configMap.getValue(t.getConfigurationId());
          final ScenarioProvider scenario = scenarioMap.getValue(t.getScenarioId());
          final ObjectiveFunction objFunc = objFuncMap.getValue(t.getObjectiveFunctionId());
          job.getDataProvider()
              .setParameter(t.getPostProcessorId(), ppMap.getValue(t.getPostProcessorId()));
          job.getDataProvider().setParameter(t.getConfigurationId(), config);
          job.getDataProvider().setParameter(t.getScenarioId(), scenario);
          job.getDataProvider().setParameter(t.getObjectiveFunctionId(), objFunc);

          job.add(t);
        } catch (final JPPFException e) {
          throw new IllegalStateException(e);
        }
        taskJobMap.put(t, job);
      }
    }

    for (final ResultListener l : listeners) {
      l.startComputing(tasks.size());
    }

    checkState(!getJPPFClient().isClosed());
    try {
      for (final JPPFJob job : jobs) {
        getJPPFClient().submitJob(job);
      }
    } catch (final Exception e) {
      throw new IllegalStateException(e);
    }
    res.awaitResults();
    for (final ResultListener l : listeners) {
      l.doneComputing();
    }
    return ExperimentResults.create(builder, res.buildResults());
  }
예제 #3
0
파일: Pixel.java 프로젝트: ocean90/amcgala
 /**
  * Erzeugt einen neuen Pixel an der Stelle (x,y). Die doubles werden entsprechend auf die
  * Integerpositionen des Pixels gerundet.
  *
  * @param x die x-Koordinate des Pixels
  * @param y die y-Koordinate des Pixels
  */
 public Pixel(double x, double y) {
   this.x = DoubleMath.roundToInt(x, RoundingMode.HALF_DOWN);
   this.y = DoubleMath.roundToInt(y, RoundingMode.HALF_DOWN);
 }
예제 #4
0
  public double findMinPerim(int leftIndex, int rightIndex, List<PointInt> listPointsSortedY) {
    int numberOfPoints = rightIndex - leftIndex + 1;
    Preconditions.checkArgument(listPointsSortedY.size() == numberOfPoints);

    if (numberOfPoints < 3) {
      return Double.MAX_VALUE;
    }

    int leftHalfEndIndex = leftIndex + numberOfPoints / 2 - 1;
    int rightHalfStartIndex = leftHalfEndIndex + 1;

    Preconditions.checkState(rightHalfStartIndex <= rightIndex);

    double min = Double.MAX_VALUE;

    /*
     * In order to avoid having to do another sort by y, (taking n log n), we just split using the sortedY list
     */
    List<PointInt> leftList = new ArrayList<>(leftHalfEndIndex - leftIndex + 1);
    List<PointInt> rightList = new ArrayList<>(rightIndex - rightHalfStartIndex + 1);

    // We must compare x and y because though we are partitioning by a vertical line, we must also
    // be able to partition if all points have the same x
    // Because the partition is strictly less and due to rounding error from longs,
    // we use this as the division point
    PointInt midPoint = list.get(rightHalfStartIndex);

    for (PointInt pl : listPointsSortedY) {
      // Verify the points are still between left and right index
      Preconditions.checkState(list.get(leftIndex).getX() <= pl.getX());
      Preconditions.checkState(list.get(rightIndex).getX() >= pl.getX());

      if (compX.compare(pl, midPoint) < 0) {
        leftList.add(pl);
      } else {
        rightList.add(pl);
      }
    }

    Preconditions.checkState(leftList.size() == numberOfPoints / 2);
    Preconditions.checkState(leftList.size() > 0);
    Preconditions.checkState(rightList.size() > 0);

    Preconditions.checkState(leftHalfEndIndex != rightIndex);
    Preconditions.checkState(rightHalfStartIndex != leftIndex);

    Preconditions.checkState(numberOfPoints == leftList.size() + rightList.size());

    // Divide
    double minLeft = findMinPerim(leftIndex, leftHalfEndIndex, leftList);
    double minRight = findMinPerim(rightHalfStartIndex, rightIndex, rightList);
    min = Math.min(minLeft, minRight);

    /*
     * For the combine, we make a box.
     * Left bound is min / 2 from vertical line, right bound is min / 2.
     *
     * Reason being that any triangle covering the vertical line and with a
     * point greater than min / 2 would have a perimeter > min.
     */

    int boxMargin =
        DoubleMath.roundToInt(
            (min > Double.MAX_VALUE / 2 ? Integer.MAX_VALUE : min) / 2d, RoundingMode.UP);
    Preconditions.checkState(min > Integer.MAX_VALUE || boxMargin < min);
    Preconditions.checkState(min > Integer.MAX_VALUE || boxMargin * 2 >= min);

    List<PointInt> boxPoints = new ArrayList<>();
    int startBox = 0;
    for (int i = 0; i < listPointsSortedY.size(); ++i) {
      PointInt point = listPointsSortedY.get(i);

      if (Math.abs(point.getX() - midPoint.getX()) > boxMargin) {
        continue;
      }

      // Calculate start of the box to consider.  Should be at most
      // boxMargin away from currenty point.  End of box is the last point added
      while (startBox < boxPoints.size()
          && point.getY() - boxPoints.get(startBox).getY() > boxMargin) {
        startBox++;
      }

      /**
       * To explain this, the box goes from -minP / 2 to + minP / 2 from the dividing vertical line.
       * Its height is also minP / 2.
       *
       * <p>Because we have the minimum with respect to the left and right sides, all triangles to
       * the left and right have max perimiter <= minP.
       *
       * <p>The only way to cram 16 points is to have 2 points on each corner and in the middle
       *
       * <p>PP-------PP--------PP
       *
       * <p>PP PP
       *
       * <p>PP-------PP--------PP
       *
       * <p>The perim of any triangle is >= minP. Any other point would be a triangle of perim <
       * minP.
       */
      Preconditions.checkState(boxPoints.size() - startBox <= 16);

      // Consider all points in box (can be proved <= 16...Similar to most 6 for closest 2 points
      // algorithm
      for (int bi = startBox; bi < boxPoints.size(); ++bi) {
        for (int j = bi + 1; j < boxPoints.size(); ++j) {
          double perim =
              point.distance(boxPoints.get(bi))
                  + point.distance(boxPoints.get(j))
                  + boxPoints.get(bi).distance(boxPoints.get(j));

          min = Math.min(min, perim);
        }
      }

      boxPoints.add(point);
    }

    return min;
  }