Version 3.18.1
Show:

File: charts/js/NumericImpl.js

            /**
             * Provides functionality for the handling of numeric axis data for a chart.
             *
             * @module charts
             * @submodule axis-numeric-base
             */
            var Y_Lang = Y.Lang;
            
            /**
             * NumericImpl contains logic for numeric data. NumericImpl is used by the following classes:
             * <ul>
             *      <li>{{#crossLink "NumericAxisBase"}}{{/crossLink}}</li>
             *      <li>{{#crossLink "NumericAxis"}}{{/crossLink}}</li>
             *  </ul>
             *
             * @class NumericImpl
             * @constructor
             * @submodule axis-numeric-base
             */
            function NumericImpl()
            {
            }
            
            NumericImpl.NAME = "numericImpl";
            
            NumericImpl.ATTRS = {
                /**
                 * Indicates whether 0 should always be displayed.
                 *
                 * @attribute alwaysShowZero
                 * @type Boolean
                 */
                alwaysShowZero: {
                    value: true
                },
            
                /**
                 * Method used for formatting a label. This attribute allows for the default label formatting method to overridden.
                 * The method use would need to implement the arguments below and return a `String` or an `HTMLElement`. The default
                 * implementation of the method returns a `String`. The output of this method will be rendered to the DOM using
                 * `appendChild`. If you override the `labelFunction` method and return an html string, you will also need to override
                 * the Data' `appendLabelFunction` to accept html as a `String`.
                 * <dl>
                 *      <dt>val</dt><dd>Label to be formatted. (`String`)</dd>
                 *      <dt>format</dt><dd>Object containing properties used to format the label. (optional)</dd>
                 * </dl>
                 *
                 * @attribute labelFunction
                 * @type Function
                 */
            
                /**
                 * Object containing properties used by the `labelFunction` to format a
                 * label.
                 *
                 * @attribute labelFormat
                 * @type Object
                 */
                labelFormat: {
                    value: {
                        prefix: "",
                        thousandsSeparator: "",
                        decimalSeparator: "",
                        decimalPlaces: "0",
                        suffix: ""
                    }
                },
            
                /**
                 *Indicates how to round unit values.
                 *  <dl>
                 *      <dt>niceNumber</dt><dd>Units will be smoothed based on the number of ticks and data range.</dd>
                 *      <dt>auto</dt><dd>If the range is greater than 1, the units will be rounded.</dd>
                 *      <dt>numeric value</dt><dd>Units will be equal to the numeric value.</dd>
                 *      <dt>null</dt><dd>No rounding will occur.</dd>
                 *  </dl>
                 *
                 * @attribute roundingMethod
                 * @type String
                 * @default niceNumber
                 */
                roundingMethod: {
                    value: "niceNumber"
                },
            
                /**
                 * Indicates the scaling for the chart. The default value is `linear`. For a logarithmic axis, set the value
                 * to `logarithmic`.
                 *
                 * @attribute
                 * @type String
                 * @default linear
                 */
                scaleType: {
                    value: "linear"
                }
            };
            
            NumericImpl.prototype = {
                /**
                 * @method initializer
                 * @private
                 */
                initializer: function() {
                    this.after("alwaysShowZeroChange", this._keyChangeHandler);
                    this.after("roundingMethodChange", this._keyChangeHandler);
                    this.after("scaleTypeChange", this._keyChangeHandler);
                },
            
                /**
                 * Formats a label based on the axis type and optionally specified format.
                 *
                 * @method
                 * @param {Object} value
                 * @param {Object} format Pattern used to format the value.
                 * @return String
                 */
                formatLabel: function(val, format)
                {
                    if(format)
                    {
                        return Y.DataType.Number.format(val, format);
                    }
                    return val;
                },
            
                /**
                 * Returns the sum of all values per key.
                 *
                 * @method getTotalByKey
                 * @param {String} key The identifier for the array whose values will be calculated.
                 * @return Number
                 */
                getTotalByKey: function(key)
                {
                    var total = 0,
                        values = this.getDataByKey(key),
                        i = 0,
                        val,
                        len = values ? values.length : 0;
                    for(; i < len; ++i)
                    {
                       val = parseFloat(values[i]);
                       if(!isNaN(val))
                       {
                            total += val;
                       }
                    }
                    return total;
                },
            
                /**
                 * Returns the value corresponding to the origin on the axis.
                 *
                 * @method getOrigin
                 * @return Number
                 */
                getOrigin: function() {
                    var origin = 0,
                        min = this.get("minimum"),
                        max = this.get("maximum");
                    origin = Math.max(origin, min);
                    origin = Math.min(origin, max);
                    return origin;
                },
            
                /**
                 * Type of data used in `Data`.
                 *
                 * @property _type
                 * @readOnly
                 * @private
                 */
                _type: "numeric",
            
                /**
                 * Helper method for getting a `roundingUnit` when calculating the minimum and maximum values.
                 *
                 * @method _getMinimumUnit
                 * @param {Number} max Maximum number
                 * @param {Number} min Minimum number
                 * @param {Number} units Number of units on the axis
                 * @return Number
                 * @private
                 */
                _getMinimumUnit:function(max, min, units)
                {
                    return this._getNiceNumber(Math.ceil((max - min)/units));
                },
            
                /**
                 * Calculates a nice rounding unit based on the range.
                 *
                 * @method _getNiceNumber
                 * @param {Number} roundingUnit The calculated rounding unit.
                 * @return Number
                 * @private
                 */
                _getNiceNumber: function(roundingUnit)
                {
                    var tempMajorUnit = roundingUnit,
                        order = Math.ceil(Math.log(tempMajorUnit) * 0.4342944819032518),
                        roundedMajorUnit = Math.pow(10, order),
                        roundedDiff;
            
                    if (roundedMajorUnit / 2 >= tempMajorUnit)
                    {
                        roundedDiff = Math.floor((roundedMajorUnit / 2 - tempMajorUnit) / (Math.pow(10,order-1)/2));
                        tempMajorUnit = roundedMajorUnit/2 - roundedDiff*Math.pow(10,order-1)/2;
                    }
                    else
                    {
                        tempMajorUnit = roundedMajorUnit;
                    }
                    if(!isNaN(tempMajorUnit))
                    {
                        return tempMajorUnit;
                    }
                    return roundingUnit;
            
                },
            
                /**
                 * Calculates the maximum and minimum values for the `Data`.
                 *
                 * @method _updateMinAndMax
                 * @private
                 */
                _updateMinAndMax: function()
                {
                    var data = this.get("data"),
                        max,
                        min,
                        len,
                        num,
                        i = 0,
                        setMax = this.get("setMax"),
                        setMin = this.get("setMin");
                    if(!setMax || !setMin)
                    {
                        if(data && data.length && data.length > 0)
                        {
                            len = data.length;
                            for(; i < len; i++)
                            {
                                num = data[i];
                                if(isNaN(num))
                                {
                                    max = setMax ? this._setMaximum : max;
                                    min = setMin ? this._setMinimum : min;
                                    continue;
                                }
            
                                if(setMin)
                                {
                                    min = this._setMinimum;
                                }
                                else if(min === undefined)
                                {
                                    min = num;
                                }
                                else
                                {
                                    min = Math.min(num, min);
                                }
                                if(setMax)
                                {
                                    max = this._setMaximum;
                                }
                                else if(max === undefined)
                                {
                                    max = num;
                                }
                                else
                                {
                                    max = Math.max(num, max);
                                }
            
                                this._actualMaximum = max;
                                this._actualMinimum = min;
                            }
                        }
                        if(this.get("scaleType") !== "logarithmic")
                        {
                            this._roundMinAndMax(min, max, setMin, setMax);
                        }
                        else
                        {
                            this._dataMaximum = max;
                            this._dataMinimum = min;
                        }
                    }
                },
            
                /**
                 * Rounds the mimimum and maximum values based on the `roundingUnit` attribute.
                 *
                 * @method _roundMinAndMax
                 * @param {Number} min Minimum value
                 * @param {Number} max Maximum value
                 * @private
                 */
                _roundMinAndMax: function(min, max, setMin, setMax)
                {
                    var roundingUnit,
                        minimumRange,
                        minGreaterThanZero = min >= 0,
                        maxGreaterThanZero = max > 0,
                        dataRangeGreater,
                        maxRound,
                        minRound,
                        topTicks,
                        botTicks,
                        tempMax,
                        tempMin,
                        units = this.getTotalMajorUnits() - 1,
                        alwaysShowZero = this.get("alwaysShowZero"),
                        roundingMethod = this.get("roundingMethod"),
                        useIntegers = (max - min)/units >= 1;
                    if(roundingMethod)
                    {
                        if(roundingMethod === "niceNumber")
                        {
                            roundingUnit = this._getMinimumUnit(max, min, units);
                            if(minGreaterThanZero && maxGreaterThanZero)
                            {
                                if((alwaysShowZero || min < roundingUnit) && !setMin)
                                {
                                    min = 0;
                                    roundingUnit = this._getMinimumUnit(max, min, units);
                                }
                                else
                                {
                                   min = this._roundDownToNearest(min, roundingUnit);
                                }
                                if(setMax)
                                {
                                    if(!alwaysShowZero)
                                    {
                                        min = max - (roundingUnit * units);
                                    }
                                }
                                else if(setMin)
                                {
                                    max = min + (roundingUnit * units);
                                }
                                else
                                {
                                    max = this._roundUpToNearest(max, roundingUnit);
                                }
                            }
                            else if(maxGreaterThanZero && !minGreaterThanZero)
                            {
                                if(alwaysShowZero)
                                {
                                    topTicks = Math.round(units/((-1 * min)/max + 1));
                                    topTicks = Math.max(Math.min(topTicks, units - 1), 1);
                                    botTicks = units - topTicks;
                                    tempMax = Math.ceil( max/topTicks );
                                    tempMin = Math.floor( min/botTicks ) * -1;
            
                                    if(setMin)
                                    {
                                        while(tempMin < tempMax && botTicks >= 0)
                                        {
                                            botTicks--;
                                            topTicks++;
                                            tempMax = Math.ceil( max/topTicks );
                                            tempMin = Math.floor( min/botTicks ) * -1;
                                        }
                                        //if there are any bottom ticks left calcualate the maximum by multiplying by the tempMin value
                                        //if not, it's impossible to ensure that a zero is shown. skip it
                                        if(botTicks > 0)
                                        {
                                            max = tempMin * topTicks;
                                        }
                                        else
                                        {
                                            max = min + (roundingUnit * units);
                                        }
                                    }
                                    else if(setMax)
                                    {
                                        while(tempMax < tempMin && topTicks >= 0)
                                        {
                                            botTicks++;
                                            topTicks--;
                                            tempMin = Math.floor( min/botTicks ) * -1;
                                            tempMax = Math.ceil( max/topTicks );
                                        }
                                        //if there are any top ticks left calcualate the minimum by multiplying by the tempMax value
                                        //if not, it's impossible to ensure that a zero is shown. skip it
                                        if(topTicks > 0)
                                        {
                                            min = tempMax * botTicks * -1;
                                        }
                                        else
                                        {
                                            min = max - (roundingUnit * units);
                                        }
                                    }
                                    else
                                    {
                                        roundingUnit = Math.max(tempMax, tempMin);
                                        roundingUnit = this._getNiceNumber(roundingUnit);
                                        max = roundingUnit * topTicks;
                                        min = roundingUnit * botTicks * -1;
                                    }
                                }
                                else
                                {
                                    if(setMax)
                                    {
                                        min = max - (roundingUnit * units);
                                    }
                                    else if(setMin)
                                    {
                                        max = min + (roundingUnit * units);
                                    }
                                    else
                                    {
                                        min = this._roundDownToNearest(min, roundingUnit);
                                        max = this._roundUpToNearest(max, roundingUnit);
                                    }
                                }
                            }
                            else
                            {
                                if(setMin)
                                {
                                    if(alwaysShowZero)
                                    {
                                        max = 0;
                                    }
                                    else
                                    {
                                        max = min + (roundingUnit * units);
                                    }
                                }
                                else if(!setMax)
                                {
                                    if(alwaysShowZero || max === 0 || max + roundingUnit > 0)
                                    {
                                        max = 0;
                                        roundingUnit = this._getMinimumUnit(max, min, units);
                                        min = max - (roundingUnit * units);
                                    }
                                    else
                                    {
                                        min = this._roundDownToNearest(min, roundingUnit);
                                        max = this._roundUpToNearest(max, roundingUnit);
                                    }
                                }
                                else
                                {
                                    min = max - (roundingUnit * units);
                                }
                            }
                        }
                        else if(roundingMethod === "auto")
                        {
                            if(minGreaterThanZero && maxGreaterThanZero)
                            {
                                if((alwaysShowZero || min < (max-min)/units) && !setMin)
                                {
                                    min = 0;
                                }
            
                                roundingUnit = (max - min)/units;
                                if(useIntegers)
                                {
                                    roundingUnit = Math.ceil(roundingUnit);
                                    max = min + (roundingUnit * units);
                                }
                                else
                                {
                                    max = min + Math.ceil(roundingUnit * units * 100000)/100000;
            
                                }
                            }
                            else if(maxGreaterThanZero && !minGreaterThanZero)
                            {
                                if(alwaysShowZero)
                                {
                                    topTicks = Math.round( units / ( (-1 * min) /max + 1) );
                                    topTicks = Math.max(Math.min(topTicks, units - 1), 1);
                                    botTicks = units - topTicks;
            
                                    if(useIntegers)
                                    {
                                        tempMax = Math.ceil( max/topTicks );
                                        tempMin = Math.floor( min/botTicks ) * -1;
                                        roundingUnit = Math.max(tempMax, tempMin);
                                        max = roundingUnit * topTicks;
                                        min = roundingUnit * botTicks * -1;
                                    }
                                    else
                                    {
                                        tempMax = max/topTicks;
                                        tempMin = min/botTicks * -1;
                                        roundingUnit = Math.max(tempMax, tempMin);
                                        max = Math.ceil(roundingUnit * topTicks * 100000)/100000;
                                        min = Math.ceil(roundingUnit * botTicks * 100000)/100000 * -1;
                                    }
                                }
                                else
                                {
                                    roundingUnit = (max - min)/units;
                                    if(useIntegers)
                                    {
                                        roundingUnit = Math.ceil(roundingUnit);
                                    }
                                    min = Math.round(this._roundDownToNearest(min, roundingUnit) * 100000)/100000;
                                    max = Math.round(this._roundUpToNearest(max, roundingUnit) * 100000)/100000;
                                }
                            }
                            else
                            {
                                roundingUnit = (max - min)/units;
                                if(useIntegers)
                                {
                                    roundingUnit = Math.ceil(roundingUnit);
                                }
                                if(alwaysShowZero || max === 0 || max + roundingUnit > 0)
                                {
                                    max = 0;
                                    roundingUnit = (max - min)/units;
                                    if(useIntegers)
                                    {
                                        Math.ceil(roundingUnit);
                                        min = max - (roundingUnit * units);
                                    }
                                    else
                                    {
                                        min = max - Math.ceil(roundingUnit * units * 100000)/100000;
                                    }
                                }
                                else
                                {
                                    min = this._roundDownToNearest(min, roundingUnit);
                                    max = this._roundUpToNearest(max, roundingUnit);
                                }
            
                            }
                        }
                        else if(!isNaN(roundingMethod) && isFinite(roundingMethod))
                        {
                            roundingUnit = roundingMethod;
                            minimumRange = roundingUnit * units;
                            dataRangeGreater = (max - min) > minimumRange;
                            minRound = this._roundDownToNearest(min, roundingUnit);
                            maxRound = this._roundUpToNearest(max, roundingUnit);
                            if(setMax)
                            {
                                min = max - minimumRange;
                            }
                            else if(setMin)
                            {
                                max = min + minimumRange;
                            }
                            else if(minGreaterThanZero && maxGreaterThanZero)
                            {
                                if(alwaysShowZero || minRound <= 0)
                                {
                                    min = 0;
                                }
                                else
                                {
                                    min = minRound;
                                }
                                max = min + minimumRange;
                            }
                            else if(maxGreaterThanZero && !minGreaterThanZero)
                            {
                                min = minRound;
                                max = maxRound;
                            }
                            else
                            {
                                if(alwaysShowZero || maxRound >= 0)
                                {
                                    max = 0;
                                }
                                else
                                {
                                    max = maxRound;
                                }
                                min = max - minimumRange;
                            }
                        }
                    }
                    this._dataMaximum = max;
                    this._dataMinimum = min;
                },
            
                /**
                 * Rounds a Number to the nearest multiple of an input. For example, by rounding
                 * 16 to the nearest 10, you will receive 20. Similar to the built-in function Math.round().
                 *
                 * @method _roundToNearest
                 * @param {Number} number Number to round
                 * @param {Number} nearest Multiple to round towards.
                 * @return Number
                 * @private
                 */
                _roundToNearest: function(number, nearest)
                {
                    nearest = nearest || 1;
                    var roundedNumber = Math.round(this._roundToPrecision(number / nearest, 10)) * nearest;
                    return this._roundToPrecision(roundedNumber, 10);
                },
            
                /**
                 * Rounds a Number up to the nearest multiple of an input. For example, by rounding
                 * 16 up to the nearest 10, you will receive 20. Similar to the built-in function Math.ceil().
                 *
                 * @method _roundUpToNearest
                 * @param {Number} number Number to round
                 * @param {Number} nearest Multiple to round towards.
                 * @return Number
                 * @private
                 */
                _roundUpToNearest: function(number, nearest)
                {
                    nearest = nearest || 1;
                    return Math.ceil(this._roundToPrecision(number / nearest, 10)) * nearest;
                },
            
                /**
                 * Rounds a Number down to the nearest multiple of an input. For example, by rounding
                 * 16 down to the nearest 10, you will receive 10. Similar to the built-in function Math.floor().
                 *
                 * @method _roundDownToNearest
                 * @param {Number} number Number to round
                 * @param {Number} nearest Multiple to round towards.
                 * @return Number
                 * @private
                 */
                _roundDownToNearest: function(number, nearest)
                {
                    nearest = nearest || 1;
                    return Math.floor(this._roundToPrecision(number / nearest, 10)) * nearest;
                },
            
                /**
                 * Returns a coordinate corresponding to a data values.
                 *
                 * @method _getCoordFromValue
                 * @param {Number} min The minimum for the axis.
                 * @param {Number} max The maximum for the axis.
                 * @param {Number} length The distance that the axis spans.
                 * @param {Number} dataValue A value used to ascertain the coordinate.
                 * @param {Number} offset Value in which to offset the coordinates.
                 * @param {Boolean} reverse Indicates whether the coordinates should start from
                 * the end of an axis. Only used in the numeric implementation.
                 * @return Number
                 * @private
                 */
                _getCoordFromValue: function(min, max, length, dataValue, offset, reverse)
                {
                    var range,
                        multiplier,
                        valuecoord,
                        isNumber = Y_Lang.isNumber;
                    dataValue = parseFloat(dataValue);
                    if(isNumber(dataValue))
                    {
                        if(this.get("scaleType") === "logarithmic" && min > 0)
                        {
                            min = Math.log(min);
                            max = Math.log(max);
                            dataValue = Math.log(dataValue);
                        }
                        range = max - min;
                        multiplier = length/range;
                        valuecoord = (dataValue - min) * multiplier;
                        valuecoord = reverse ? offset - valuecoord : offset + valuecoord;
                    }
                    else
                    {
                        valuecoord = NaN;
                    }
                    return valuecoord;
                },
            
                /**
                 * Rounds a number to a certain level of precision. Useful for limiting the number of
                 * decimal places on a fractional number.
                 *
                 * @method _roundToPrecision
                 * @param {Number} number Number to round
                 * @param {Number} precision Multiple to round towards.
                 * @return Number
                 * @private
                 */
                _roundToPrecision: function(number, precision)
                {
                    precision = precision || 0;
                    var decimalPlaces = Math.pow(10, precision);
                    return Math.round(decimalPlaces * number) / decimalPlaces;
                }
            };
            
            Y.NumericImpl = NumericImpl;