Tabnine Logo
org.jfree.data.xy
Code IndexAdd Tabnine to your IDE (free)

How to use org.jfree.data.xy

Best Java code snippets using org.jfree.data.xy (Showing top 20 results out of 639)

origin: kiegroup/optaplanner

protected boolean useLogarithmicProblemScale(List<XYSeries> seriesList) {
  NavigableSet<Double> xValueSet = new TreeSet<>();
  int xValueListSize = 0;
  for (XYSeries series : seriesList) {
    for (XYDataItem dataItem : (List<XYDataItem>) series.getItems()) {
      xValueSet.add(dataItem.getXValue());
      xValueListSize++;
    }
  }
  if (xValueListSize < LOG_SCALE_MIN_DATASETS_COUNT) {
    return false;
  }
  // If 60% of the points are in 20% of the value space, use a logarithmic scale
  double threshold = 0.2 * (xValueSet.last() - xValueSet.first());
  int belowThresholdCount = xValueSet.headSet(threshold).size();
  return belowThresholdCount >= (0.6 * xValueSet.size());
}
origin: kiegroup/optaplanner

private XYPlot createPeriodCostPlot(TangoColorFactory tangoColorFactory, CheapTimeSolution solution) {
  XYSeries series = new XYSeries("Power price");
  for (PeriodPowerPrice periodPowerPrice : solution.getPeriodPowerPriceList()) {
    series.add((double) periodPowerPrice.getPowerPriceMicros() / 1000000.0, periodPowerPrice.getPeriod());
  }
  XYSeriesCollection seriesCollection = new XYSeriesCollection();
  seriesCollection.addSeries(series);
  XYItemRenderer renderer = new StandardXYItemRenderer(StandardXYItemRenderer.SHAPES);
  renderer.setSeriesPaint(0, TangoColorFactory.ORANGE_1);
  renderer.setSeriesShape(0, ShapeUtilities.createDiamond(2.0F));
  NumberAxis domainAxis = new NumberAxis("Power price");
  return new XYPlot(seriesCollection, domainAxis, null, renderer);
}
origin: kiegroup/optaplanner

      k -> new XYSeries(point.getConstraintName() + " weight"));
  if (levelValues[i] != ((weightSeries.getItemCount() == 0) ? 0.0
      : weightSeries.getY(weightSeries.getItemCount() - 1).doubleValue())) {
    weightSeries.add(timeMillisSpent, levelValues[i]);
for (Iterator<Map.Entry<String, XYSeries>> it = constraintIdToWeightSeriesMap.entrySet().iterator(); it.hasNext(); ) {
  XYSeries weightSeries = it.next().getValue();
  if (weightSeries.getItemCount() == 0) {
    weightSeries.add(timeMillisSpent, weightSeries.getY(weightSeries.getItemCount() - 1).doubleValue());
XYSeriesCollection seriesCollection = new XYSeriesCollection();
for (XYSeries series : constraintIdToWeightSeriesMapList.get(scoreLevelIndex).values()) {
  seriesCollection.addSeries(series);
origin: kiegroup/optaplanner

  for (int i = 0; i < levelValues.length && i < BenchmarkReport.CHARTED_SCORE_LEVEL_SIZE; i++) {
    if (i >= seriesList.size()) {
      seriesList.add(new XYSeries(
          singleBenchmarkResult.getSolverBenchmarkResult().getNameWithFavoriteSuffix()));
    seriesList.get(i).add(timeMillisSpent, levelValues[i]);
  plotList.add(createPlot(benchmarkReport, i));
plotList.get(i).setDataset(seriesIndex, new XYSeriesCollection(seriesList.get(i)));
plotList.get(i).setRenderer(seriesIndex, renderer);
origin: kiegroup/optaplanner

private void writeScoreCalculationSpeedSummaryChart() {
  List<XYSeries> seriesList = new ArrayList<>(plannerBenchmarkResult.getSolverBenchmarkResultList().size());
  for (SolverBenchmarkResult solverBenchmarkResult : plannerBenchmarkResult.getSolverBenchmarkResultList()) {
    String solverLabel = solverBenchmarkResult.getNameWithFavoriteSuffix();
    XYSeries series = new XYSeries(solverLabel);
    for (SingleBenchmarkResult singleBenchmarkResult : solverBenchmarkResult.getSingleBenchmarkResultList()) {
      if (singleBenchmarkResult.hasAllSuccess()) {
        long problemScale = singleBenchmarkResult.getProblemBenchmarkResult().getProblemScale();
        long scoreCalculationSpeed = singleBenchmarkResult.getScoreCalculationSpeed();
        series.add((Long) problemScale, (Long) scoreCalculationSpeed);
      }
    }
    seriesList.add(series);
  }
  XYPlot plot = createScalabilityPlot(seriesList,
      "Problem scale", NumberFormat.getInstance(locale),
      "Score calculation speed per second", NumberFormat.getInstance(locale));
  JFreeChart chart = new JFreeChart("Score calculation speed summary (higher is better)",
      JFreeChart.DEFAULT_TITLE_FONT, plot, true);
  scoreCalculationSpeedSummaryChartFile = writeChartToImageFile(chart, "scoreCalculationSpeedSummary");
}
origin: kiegroup/optaplanner

private XYPlot createScalabilityPlot(List<XYSeries> seriesList,
    String xAxisLabel, NumberFormat xAxisNumberFormat,
    String yAxisLabel, NumberFormat yAxisNumberFormat) {
  NumberAxis xAxis;
  if (useLogarithmicProblemScale(seriesList)) {
    LogarithmicAxis logarithmicAxis = new LogarithmicAxis(xAxisLabel + " (logarithmic)");
    logarithmicAxis.setAllowNegativesFlag(true);
    xAxis = logarithmicAxis;
  } else {
    xAxis = new NumberAxis(xAxisLabel);
  }
  xAxis.setNumberFormatOverride(xAxisNumberFormat);
  NumberAxis yAxis = new NumberAxis(yAxisLabel);
  yAxis.setNumberFormatOverride(yAxisNumberFormat);
  XYPlot plot = new XYPlot(null, xAxis, yAxis, null);
  int seriesIndex = 0;
  for (XYSeries series : seriesList) {
    XYSeriesCollection seriesCollection = new XYSeriesCollection();
    seriesCollection.addSeries(series);
    plot.setDataset(seriesIndex, seriesCollection);
    XYItemRenderer renderer = createScalabilityPlotRenderer(yAxisNumberFormat);
    plot.setRenderer(seriesIndex, renderer);
    seriesIndex++;
  }
  plot.setOrientation(PlotOrientation.VERTICAL);
  return plot;
}
origin: kiegroup/optaplanner

      k -> new XYIntervalSeries(moveType));
  double yValue = levelValues[i];
  series.add(timeMillisSpent, timeMillisSpent, timeMillisSpent,
      yValue, (yValue > 0.0) ? 0.0 : yValue, (yValue > 0.0) ? yValue : 0.0);
XYItemRenderer renderer = new YIntervalRenderer();
plot.setRenderer(renderer);
XYIntervalSeriesCollection seriesCollection = new XYIntervalSeriesCollection();
for (XYIntervalSeries series : moveTypeToSeriesMapList.get(scoreLevelIndex).values()) {
  seriesCollection.addSeries(series);
origin: kiegroup/optaplanner

private JFreeChart createChart(Schedule schedule) {
  YIntervalSeriesCollection seriesCollection = new YIntervalSeriesCollection();
  Map<Project, YIntervalSeries> projectSeriesMap = new LinkedHashMap<>(
      schedule.getProjectList().size());
  int seriesIndex = 0;
  for (Project project : schedule.getProjectList()) {
    YIntervalSeries projectSeries = new YIntervalSeries(project.getLabel());
    seriesCollection.addSeries(projectSeries);
    projectSeriesMap.put(project, projectSeries);
    renderer.setSeriesShape(seriesIndex, new Rectangle());
    int endDate = allocation.getEndDate();
    YIntervalSeries projectSeries = projectSeriesMap.get(allocation.getProject());
    projectSeries.add(allocation.getId(), (startDate + endDate) / 2.0,
        startDate, endDate);
    maximumEndDate = Math.max(maximumEndDate, endDate);
origin: stackoverflow.com

int rows = 20;
double[][] values = new double[cols][rows];
XYSeriesCollection xySeriesCollection = new XYSeriesCollection();
XYSeries series = new XYSeries("Random");
Random rand = new Random();
for (int i = 0; i < values.length; i++) {
    double x = rand.nextGaussian();
    double y = rand.nextGaussian();
    series.add(x, y);
xySeriesCollection.addSeries(series);
return xySeriesCollection;
origin: kiegroup/optaplanner

      k -> new XYSeries(point.getConstraintName() + " weight"));
  if (levelValues[i] != ((weightSeries.getItemCount() == 0) ? 0.0
      : weightSeries.getY(weightSeries.getItemCount() - 1).doubleValue())) {
    weightSeries.add(timeMillisSpent, levelValues[i]);
for (Iterator<Map.Entry<String, XYSeries>> it = constraintIdToWeightSeriesMap.entrySet().iterator(); it.hasNext(); ) {
  XYSeries weightSeries = it.next().getValue();
  if (weightSeries.getItemCount() == 0) {
    weightSeries.add(timeMillisSpent, weightSeries.getY(weightSeries.getItemCount() - 1).doubleValue());
XYSeriesCollection seriesCollection = new XYSeriesCollection();
for (XYSeries series : constraintIdToWeightSeriesMapList.get(scoreLevelIndex).values()) {
  seriesCollection.addSeries(series);
origin: kiegroup/optaplanner

int seriesIndex = 0;
for (SingleBenchmarkResult singleBenchmarkResult : problemBenchmarkResult.getSingleBenchmarkResultList()) {
  XYSeries series = new XYSeries(singleBenchmarkResult.getSolverBenchmarkResult().getNameWithFavoriteSuffix());
  XYItemRenderer renderer = new XYLineAndShapeRenderer();
  if (singleBenchmarkResult.hasAllSuccess()) {
      long timeMillisSpent = point.getTimeMillisSpent();
      long scoreCalculationSpeed = point.getScoreCalculationSpeed();
      series.add(timeMillisSpent, scoreCalculationSpeed);
  plot.setDataset(seriesIndex, new XYSeriesCollection(series));
origin: kiegroup/optaplanner

  seriesList.add(new XYSeries(solverLabel));
seriesList.get(solverBenchmarkIndex).add((double) problemScale, levelValues[i]);
origin: kiegroup/optaplanner

      k -> new XYIntervalSeries(moveType));
  double yValue = levelValues[i];
  series.add(timeMillisSpent, timeMillisSpent, timeMillisSpent,
      yValue, (yValue > 0.0) ? 0.0 : yValue, (yValue > 0.0) ? yValue : 0.0);
XYItemRenderer renderer = new YIntervalRenderer();
plot.setRenderer(renderer);
XYIntervalSeriesCollection seriesCollection = new XYIntervalSeriesCollection();
for (XYIntervalSeries series : moveTypeToSeriesMapList.get(scoreLevelIndex).values()) {
  seriesCollection.addSeries(series);
origin: stackoverflow.com

private static final String title = "Scatter Add Demo";
private static final Random rand = new Random();
private XYSeries added = new XYSeries("Added");
    public void actionPerformed(ActionEvent e) {
      for (int i = 0; i < N; i++) {
        added.add(rand.nextDouble(), rand.nextDouble());
  XYSeriesCollection xySeriesCollection = new XYSeriesCollection();
  XYSeries series = new XYSeries("Random");
  for (int i = 0; i < N * N; i++) {
    double x = rand.nextDouble();
    double y = rand.nextDouble();
    series.add(x, y);
  xySeriesCollection.addSeries(series);
  xySeriesCollection.addSeries(added);
  return xySeriesCollection;
origin: kiegroup/optaplanner

  seriesList.add(new XYSeries(solverLabel));
seriesList.get(solverBenchmarkIndex).add((Long) timeMillisSpent, (Double) levelValues[i]);
origin: kiegroup/optaplanner

int seriesIndex = 0;
for (SingleBenchmarkResult singleBenchmarkResult : problemBenchmarkResult.getSingleBenchmarkResultList()) {
  XYIntervalSeries series = new XYIntervalSeries(singleBenchmarkResult.getSolverBenchmarkResult().getNameWithFavoriteSuffix());
  XYItemRenderer renderer = new YIntervalRenderer();
  if (singleBenchmarkResult.hasAllSuccess()) {
      double yValue = mutationCount;
      series.add(timeMillisSpent, timeMillisSpent, timeMillisSpent,
          yValue, (yValue > 0.0) ? 0.0 : yValue, (yValue > 0.0) ? yValue : 0.0);
  XYIntervalSeriesCollection dataset = new XYIntervalSeriesCollection();
  dataset.addSeries(series);
  plot.setDataset(seriesIndex, dataset);
origin: kiegroup/optaplanner

XYSeriesCollection seriesCollection = new XYSeriesCollection();
XYItemRenderer renderer = new StandardXYItemRenderer(StandardXYItemRenderer.SHAPES);
int seriesIndex = 0;
for (Machine machine : solution.getMachineList()) {
  XYSeries machineSeries = new XYSeries(machine.getLabel());
  for (MachineCapacity machineCapacity : machine.getMachineCapacityList()) {
    List<Integer> machineAvailableList = availableMap.get(machineCapacity);
    for (int period = 0; period < solution.getGlobalPeriodRangeTo(); period++) {
      int available = machineAvailableList.get(period);
      machineSeries.add(available, period);
  seriesCollection.addSeries(machineSeries);
  renderer.setSeriesPaint(seriesIndex, tangoColorFactory.pickColor(machine));
  renderer.setSeriesShape(seriesIndex, ShapeUtilities.createDiamond(1.5F));
origin: kiegroup/optaplanner

private void writeTimeSpentScalabilitySummaryChart() {
  List<XYSeries> seriesList = new ArrayList<>(plannerBenchmarkResult.getSolverBenchmarkResultList().size());
  for (SolverBenchmarkResult solverBenchmarkResult : plannerBenchmarkResult.getSolverBenchmarkResultList()) {
    String solverLabel = solverBenchmarkResult.getNameWithFavoriteSuffix();
    XYSeries series = new XYSeries(solverLabel);
    for (SingleBenchmarkResult singleBenchmarkResult : solverBenchmarkResult.getSingleBenchmarkResultList()) {
      if (singleBenchmarkResult.hasAllSuccess()) {
        long problemScale = singleBenchmarkResult.getProblemBenchmarkResult().getProblemScale();
        long timeMillisSpent = singleBenchmarkResult.getTimeMillisSpent();
        series.add((Long) problemScale, (Long) timeMillisSpent);
      }
    }
    seriesList.add(series);
  }
  XYPlot plot = createScalabilityPlot(seriesList,
      "Problem scale", NumberFormat.getInstance(locale),
      "Time spent", new MillisecondsSpentNumberFormat(locale));
  JFreeChart chart = new JFreeChart("Time spent scalability summary (lower is better)",
      JFreeChart.DEFAULT_TITLE_FONT, plot, true);
  timeSpentScalabilitySummaryChartFile = writeChartToImageFile(chart, "timeSpentScalabilitySummary");
}
origin: kiegroup/optaplanner

XYSeries acceptedSeries = new XYSeries(
    singleBenchmarkResult.getSolverBenchmarkResult().getNameWithFavoriteSuffix() + " accepted");
XYSeries selectedSeries = new XYSeries(
    singleBenchmarkResult.getSolverBenchmarkResult().getNameWithFavoriteSuffix() + " selected");
XYItemRenderer renderer = new XYLineAndShapeRenderer(true, false);
    long acceptedMoveCount = point.getMoveCountPerStepMeasurement().getAcceptedMoveCount();
    long selectedMoveCount = point.getMoveCountPerStepMeasurement().getSelectedMoveCount();
    acceptedSeries.add(timeMillisSpent, acceptedMoveCount);
    selectedSeries.add(timeMillisSpent, selectedMoveCount);
XYSeriesCollection seriesCollection = new XYSeriesCollection();
seriesCollection.addSeries(acceptedSeries);
seriesCollection.addSeries(selectedSeries);
plot.setDataset(seriesIndex, seriesCollection);
origin: kiegroup/optaplanner

int seriesIndex = 0;
for (SingleBenchmarkResult singleBenchmarkResult : problemBenchmarkResult.getSingleBenchmarkResultList()) {
  XYSeries usedSeries = new XYSeries(
      singleBenchmarkResult.getSolverBenchmarkResult().getNameWithFavoriteSuffix() + " used");
      long timeMillisSpent = point.getTimeMillisSpent();
      MemoryUseMeasurement memoryUseMeasurement = point.getMemoryUseMeasurement();
      usedSeries.add(timeMillisSpent, memoryUseMeasurement.getUsedMemory());
  XYSeriesCollection seriesCollection = new XYSeriesCollection();
  seriesCollection.addSeries(usedSeries);
org.jfree.data.xy

Most used classes

  • XYSeries
    Represents a sequence of zero or more data items in the form (x, y). By default, items in the series
  • XYSeriesCollection
    Represents a collection of XYSeries objects that can be used as a dataset.
  • XYDataset
    An interface through which data in the form of (x, y) items can be accessed.
  • DefaultXYDataset
    A default implementation of the XYDataset interface that stores data values in arrays of double prim
  • XYDataItem
    Represents one (x, y) data item for an XYSeries. Note that subclasses are REQUIRED to support clonin
  • XYIntervalSeries,
  • XYIntervalSeriesCollection,
  • DefaultXYZDataset,
  • YIntervalSeries,
  • YIntervalSeriesCollection,
  • DefaultHighLowDataset,
  • IntervalXYDataset,
  • TableXYDataset,
  • XIntervalSeries,
  • XIntervalSeriesCollection,
  • XYBarDataset,
  • XYZDataset,
  • AbstractIntervalXYDataset,
  • CategoryTableXYDataset
Tabnine Logo
  • Products

    Search for Java codeSearch for JavaScript code
  • IDE Plugins

    IntelliJ IDEAWebStormVisual StudioAndroid StudioEclipseVisual Studio CodePyCharmSublime TextPhpStormVimGoLandRubyMineEmacsJupyter NotebookJupyter LabRiderDataGripAppCode
  • Company

    About UsContact UsCareers
  • Resources

    FAQBlogTabnine AcademyTerms of usePrivacy policyJava Code IndexJavascript Code Index
Get Tabnine for your IDE now