Proyectos de Subversion Moodle

YUI.add('axis-numeric-base', function (Y, NAME) {

/**

 * 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;

/**

 * NumericAxisBase manages numeric data for an axis.

 *

 * @class NumericAxisBase

 * @constructor

 * @extends AxisBase

 * @uses NumericImpl

 * @param {Object} config (optional) Configuration parameters.

 * @submodule axis-numeric-base

 */

Y.NumericAxisBase = Y.Base.create("numericAxisBase", Y.AxisBase, [Y.NumericImpl]);

}, '3.18.1', {"requires": ["axis-base"]});