Java MathHelper类代码示例

import org.achartengine.util.MathHelper; //导入依赖的package包/类
protected Map<Integer, List<Double>> getYLabels(double[] minY, double[] maxY, int maxScaleNumber) {
  Map<Integer, List<Double>> allYLabels = new HashMap<Integer, List<Double>>();
  for (int i = 0; i < maxScaleNumber; i++) {
    allYLabels.put(i,
        getValidLabels(MathHelper.getLabels(minY[i], maxY[i], mRenderer.getYLabels())));
  }
  return allYLabels;
}
 

import org.achartengine.util.MathHelper; //导入依赖的package包/类
public void initAxesRangeForScale(int i) {
  mMinX[i] = MathHelper.NULL_VALUE;
  mMaxX[i] = -MathHelper.NULL_VALUE;
  mMinY[i] = MathHelper.NULL_VALUE;
  mMaxY[i] = -MathHelper.NULL_VALUE;
  double[] range = new double[] { mMinX[i], mMaxX[i], mMinY[i], mMaxY[i] };
  initialRange.put(i, range);
  mYTitle[i] = "";
  mYTextLabels.put(i, new HashMap<Double, String>());
  yLabelsAlign[i] = Align.CENTER;
  yAxisAlign[i] = Align.LEFT;
}
 

import org.achartengine.util.MathHelper; //导入依赖的package包/类
/**
 * Initializes the range for both axes.
 */
private void initRange() {
  mMinX = MathHelper.NULL_VALUE;
  mMaxX = -MathHelper.NULL_VALUE;
  mMinY = MathHelper.NULL_VALUE;
  mMaxY = -MathHelper.NULL_VALUE;
  int length = getItemCount();
  for (int k = 0; k < length; k++) {
    double x = getX(k);
    double y = getY(k);
    updateRange(x, y);
  }
}
 

import org.achartengine.util.MathHelper; //导入依赖的package包/类
/**
 * Initializes the values range.
 */
private void initRange() {
  mMinValue = MathHelper.NULL_VALUE;
  mMaxValue = MathHelper.NULL_VALUE;
  int length = getItemCount();
  for (int k = 0; k < length; k++) {
    updateRange(getValue(k));
  }
}
 

import org.achartengine.util.MathHelper; //导入依赖的package包/类
/**
 * Creates a discontinuity of the satellites that has been seen but not reported in this batch
 * of measurements
 */
private void fillInDiscontinuity(int tab, double referenceTimeSeconds) {
  for (XYMultipleSeriesDataset dataSet : mDataSetList[tab]) {
    for (int i = 0; i < dataSet.getSeriesCount(); i++) {
      if (dataSet.getSeriesAt(i).getMaxX() < referenceTimeSeconds) {
        dataSet.getSeriesAt(i).add(referenceTimeSeconds, MathHelper.NULL_VALUE);
      }
    }
  }
}
 

import org.achartengine.util.MathHelper; //导入依赖的package包/类
/**
 * Initializes the values range.
 */
private void initRange() {
  mMinValue = MathHelper.NULL_VALUE;
  mMaxValue = -MathHelper.NULL_VALUE;
  int length = getItemCount();
  for (int k = 0; k < length; k++) {
    updateRange(getValue(k));
  }
}
 

import org.achartengine.util.MathHelper; //导入依赖的package包/类
protected Map getYLabels(double ad[], double ad1[], int i)
{
    HashMap hashmap = new HashMap();
    for (int j = 0; j < i; j++)
    {
        hashmap.put(Integer.valueOf(j), a(MathHelper.getLabels(ad[j], ad1[j], mRenderer.getYLabels())));
    }

    return hashmap;
}
 

import org.achartengine.util.MathHelper; //导入依赖的package包/类
protected Map<Integer, List<Double>> getYLabels(double[] minY, double[] maxY, int maxScaleNumber, double[] minimumDistance) {
  Map<Integer, List<Double>> allYLabels = new HashMap<Integer, List<Double>>();
  for (int i = 0; i < maxScaleNumber; i++) {
    allYLabels.put(i,
        getValidLabels(MathHelper.getLabels(minY[i], maxY[i], mRenderer.getYLabels(), minimumDistance[i])));
  }
  return allYLabels;
}
 

import org.achartengine.util.MathHelper; //导入依赖的package包/类
protected List<Double> getXLabels(double min, double max, int count) {
  return MathHelper.getLabels(min, max, count);
}
 

import org.achartengine.util.MathHelper; //导入依赖的package包/类
public boolean isNullValue(double value) {
  return Double.isNaN(value) || Double.isInfinite(value) || value == MathHelper.NULL_VALUE;
}
 

import org.achartengine.util.MathHelper; //导入依赖的package包/类
/**
 * Apply the tool.
 */
public void apply() {
  if (mChart instanceof XYChart) {
    if (((XYChart) mChart).getDataset() == null) {
      return;
    }
    int scales = mRenderer.getScalesCount();
    if (mRenderer.isInitialRangeSet()) {
      for (int i = 0; i < scales; i++) {
        if (mRenderer.isInitialRangeSet(i)) {
          mRenderer.setRange(mRenderer.getInitialRange(i), i);
        }
      }
    } else {
      XYSeries[] series = ((XYChart) mChart).getDataset().getSeries();
      double[] range = null;
      int length = series.length;
      if (length > 0) {
        for (int i = 0; i < scales; i++) {
          range = new double[] { MathHelper.NULL_VALUE, -MathHelper.NULL_VALUE,
              MathHelper.NULL_VALUE, -MathHelper.NULL_VALUE };
          for (int j = 0; j < length; j++) {
            if (i == series[j].getScaleNumber()) {
              range[0] = Math.min(range[0], series[j].getMinX());
              range[1] = Math.max(range[1], series[j].getMaxX());
              range[2] = Math.min(range[2], series[j].getMinY());
              range[3] = Math.max(range[3], series[j].getMaxY());
            }
          }
          double marginX = Math.abs(range[1] - range[0]) / 40;
          double marginY = Math.abs(range[3] - range[2]) / 40;
          mRenderer.setRange(new double[] { range[0] - marginX, range[1] + marginX,
              range[2] - marginY, range[3] + marginY }, i);
        }
      }
    }
  } else {
    DefaultRenderer renderer = ((RoundChart) mChart).getRenderer();
    renderer.setScale(renderer.getOriginalScale());
  }
}
 

import org.achartengine.util.MathHelper; //导入依赖的package包/类
protected List getXLabels(double d1, double d2, int i)
{
    return MathHelper.getLabels(d1, d2, i);
}
 

import org.achartengine.util.MathHelper; //导入依赖的package包/类
protected List<Double> getXLabels(double min, double max, int count, double minimumDistance) {
  return MathHelper.getLabels(min, max, count, minimumDistance);
}
 

import org.achartengine.util.MathHelper; //导入依赖的package包/类
/**
 * Returns the default axis minimum.
 * 
 * @return the default axis minimum
 */
public double getDefaultMinimum() {
  return MathHelper.NULL_VALUE;
}
 

import org.achartengine.util.MathHelper; //导入依赖的package包/类
/**
 * Returns if the minimum dial value was set.
 * 
 * @return the minimum dial value was set or not
 */
public boolean isMinValueSet() {
  return mMinValue != MathHelper.NULL_VALUE;
}