--- /dev/null
+/**\r
+ * Copyright (C) 2009 - 2012 SC 4ViewSoft SRL\r
+ * \r
+ * Licensed under the Apache License, Version 2.0 (the "License");\r
+ * you may not use this file except in compliance with the License.\r
+ * You may obtain a copy of the License at\r
+ * \r
+ * http://www.apache.org/licenses/LICENSE-2.0\r
+ * \r
+ * Unless required by applicable law or agreed to in writing, software\r
+ * distributed under the License is distributed on an "AS IS" BASIS,\r
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.\r
+ * See the License for the specific language governing permissions and\r
+ * limitations under the License.\r
+ */\r
+package org.achartengine.util;\r
+\r
+import java.text.NumberFormat;\r
+import java.text.ParseException;\r
+import java.util.ArrayList;\r
+import java.util.List;\r
+\r
+/**\r
+ * Utility class for math operations.\r
+ */\r
+public class MathHelper {\r
+ /** A value that is used a null value. */\r
+ public static final double NULL_VALUE = Double.MAX_VALUE;\r
+ /**\r
+ * A number formatter to be used to make sure we have a maximum number of\r
+ * fraction digits in the labels.\r
+ */\r
+ private static final NumberFormat FORMAT = NumberFormat.getNumberInstance();\r
+\r
+ private MathHelper() {\r
+ // empty constructor\r
+ }\r
+\r
+ /**\r
+ * Calculate the minimum and maximum values out of a list of doubles.\r
+ * \r
+ * @param values the input values\r
+ * @return an array with the minimum and maximum values\r
+ */\r
+ public static double[] minmax(List<Double> values) {\r
+ if (values.size() == 0) {\r
+ return new double[2];\r
+ }\r
+ double min = values.get(0);\r
+ double max = min;\r
+ int length = values.size();\r
+ for (int i = 1; i < length; i++) {\r
+ double value = values.get(i);\r
+ min = Math.min(min, value);\r
+ max = Math.max(max, value);\r
+ }\r
+ return new double[] { min, max };\r
+ }\r
+\r
+ /**\r
+ * Computes a reasonable set of labels for a data interval and number of\r
+ * labels.\r
+ * \r
+ * @param start start value\r
+ * @param end final value\r
+ * @param approxNumLabels desired number of labels\r
+ * @return collection containing {start value, end value, increment}\r
+ */\r
+ public static List<Double> getLabels(final double start, final double end,\r
+ final int approxNumLabels) {\r
+ FORMAT.setMaximumFractionDigits(5);\r
+ List<Double> labels = new ArrayList<Double>();\r
+ double[] labelParams = computeLabels(start, end, approxNumLabels);\r
+ // when the start > end the inc will be negative so it will still work\r
+ int numLabels = 1 + (int) ((labelParams[1] - labelParams[0]) / labelParams[2]);\r
+ // we want the range to be inclusive but we don't want to blow up when\r
+ // looping for the case where the min and max are the same. So we loop\r
+ // on\r
+ // numLabels not on the values.\r
+ for (int i = 0; i < numLabels; i++) {\r
+ double z = labelParams[0] + i * labelParams[2];\r
+ try {\r
+ // this way, we avoid a label value like 0.4000000000000000001 instead\r
+ // of 0.4\r
+ z = FORMAT.parse(FORMAT.format(z)).doubleValue();\r
+ } catch (ParseException e) {\r
+ // do nothing here\r
+ }\r
+ labels.add(z);\r
+ }\r
+ return labels;\r
+ }\r
+\r
+ /**\r
+ * Computes a reasonable number of labels for a data range.\r
+ * \r
+ * @param start start value\r
+ * @param end final value\r
+ * @param approxNumLabels desired number of labels\r
+ * @return double[] array containing {start value, end value, increment}\r
+ */\r
+ private static double[] computeLabels(final double start, final double end,\r
+ final int approxNumLabels) {\r
+ if (Math.abs(start - end) < 0.0000001f) {\r
+ return new double[] { start, start, 0 };\r
+ }\r
+ double s = start;\r
+ double e = end;\r
+ boolean switched = false;\r
+ if (s > e) {\r
+ switched = true;\r
+ double tmp = s;\r
+ s = e;\r
+ e = tmp;\r
+ }\r
+ double xStep = roundUp(Math.abs(s - e) / approxNumLabels);\r
+ // Compute x starting point so it is a multiple of xStep.\r
+ double xStart = xStep * Math.ceil(s / xStep);\r
+ double xEnd = xStep * Math.floor(e / xStep);\r
+ if (switched) {\r
+ return new double[] { xEnd, xStart, -1.0 * xStep };\r
+ }\r
+ return new double[] { xStart, xEnd, xStep };\r
+ }\r
+\r
+ /**\r
+ * Given a number, round up to the nearest power of ten times 1, 2, or 5. The\r
+ * argument must be strictly positive.\r
+ */\r
+ private static double roundUp(final double val) {\r
+ int exponent = (int) Math.floor(Math.log10(val));\r
+ double rval = val * Math.pow(10, -exponent);\r
+ if (rval > 5.0) {\r
+ rval = 10.0;\r
+ } else if (rval > 2.0) {\r
+ rval = 5.0;\r
+ } else if (rval > 1.0) {\r
+ rval = 2.0;\r
+ }\r
+ rval *= Math.pow(10, exponent);\r
+ return rval;\r
+ }\r
+\r
+ /**\r
+ * Transforms a list of Float values into an array of float.\r
+ * \r
+ * @param values the list of Float\r
+ * @return the array of floats\r
+ */\r
+ public static float[] getFloats(List<Float> values) {\r
+ int length = values.size();\r
+ float[] result = new float[length];\r
+ for (int i = 0; i < length; i++) {\r
+ result[i] = values.get(i).floatValue();\r
+ }\r
+ return result;\r
+ }\r
+\r
+ /**\r
+ * Transforms a list of Double values into an array of double.\r
+ * \r
+ * @param values the list of Double\r
+ * @return the array of doubles\r
+ */\r
+ public static double[] getDoubles(List<Double> values) {\r
+ int length = values.size();\r
+ double[] result = new double[length];\r
+ for (int i = 0; i < length; i++) {\r
+ result[i] = values.get(i).doubleValue();\r
+ }\r
+ return result;\r
+ }\r
+\r
+}\r
projects / debian / openrocket / blobdiff