Main.java Source code

Introduction

Here is the source code for Main.java

Source

//package com.java2s;
/*
 JOpenChart Java Charting Library and Toolkit
 Copyright (C) 2001  Sebastian Mller
 http://jopenchart.sourceforge.net
    
 This library is free software; you can redistribute it and/or
 modify it under the terms of the GNU Lesser General Public
 License as published by the Free Software Foundation; either
 version 2.1 of the License, or (at your option) any later version.
    
 This library is distributed in the hope that it will be useful,
 but WITHOUT ANY WARRANTY; without even the implied warranty of
 MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
 Lesser General Public License for more details.
    
 You should have received a copy of the GNU Lesser General Public
 License along with this library; if not, write to the Free Software
 Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA  02111-1307  USA
    
 ChartUtilities.java
 Created on 21. September 2001, 17:42
 */

public class Main {
    /** This method calculates the optimal rounding for the minimal and
     * maximal ChartModel values. It computes the difference of the
     * minimal and maximal value and rounds the values min and max according
     * to the exponent of the difference.
     * @param min the minimal column value of the ChartDataModel
     * @param max the maximal column value of the ChartDataModel
     * @return a double[] with the rounded minimal value at index 0 and
     * the maximal value at index 1.
     */
    public static double[] performAutoScale(double min, double max) {
        double[] d = new double[2]; // d[0] = min d[1] = max

        double diff = max - min;

        d[0] = floor(min, exp(diff));
        d[1] = ceil(max, exp(diff));

        return d;
    }

    /** This method returns the largest double value that is smaller than
     * <code> d = x * 10<sup>exp</sup></code> where x is rounded down to
     * the closest integer.
     * @param d the double value to be rounded
     * @param exp the exponent of 10 to which d should be rounded
     * @return <code> Math.floor(x) * 10<sup>exp</sup></code>
     */
    public static double floor(double d, int exp) {
        double x = 1.0 * Math.pow(10.0, (double) exp);

        return Math.floor(d / x) * x;
    }

    /** A double value can be represented like 
     * <code>d = x * 10<sup>exp</sup></code> and this method returns
     * the value of exp for a double d.
     * @param d the double value
     * @return the exponent of 10
     */
    public static int exp(double d) {
        int exp = 0;
        boolean positive = (d <= -1 || d >= 1);

        while ((d <= -10) || (d >= 10) || ((d > -1) && (d < 1))) {
            if (positive) {
                d /= 10;
                exp++;
            } else {
                d *= 10;
                exp--;
            }
        }

        return exp;
    }

    /** This method returns the smallest double value that is smaller than
     * <code> d = x * 10<sup>exp</exp></code> where x is rounded up to
     * the closest integer.
     * @param d the double value to be rounded
     * @param exp the exponent of 10 to which d should be rounded
     * @return <code> Math.ceil(x) * 10<sup>exp</sup></code>
     */
    public static double ceil(double d, int exp) {
        double x = 1.0 * Math.pow(10.0, (double) exp);

        return Math.ceil(d / x) * x;
    }
}