/**
                             * Provides core functionality for the handling of stacked numeric axis data for a chart.
                             *
                             * @module charts
                             * @submodule axis-stacked-base
                             */
                            
                            /**
                             * StackedImpl contains logic for managing stacked numeric data. StackedImpl is used by the following classes:
                             * <ul>
                             *      <li>{{#crossLink "StackedAxisBase"}}{{/crossLink}}</li>
                             *      <li>{{#crossLink "StackedAxis"}}{{/crossLink}}</li>
                             *  </ul>
                             *
                             * @submodule axis-stacked-base
                             * @class StackedImpl
                             * @constructor
                             */
                            function StackedImpl()
                            {
                            }
                            
                            StackedImpl.NAME = "stackedImpl";
                            
                            StackedImpl.prototype = {
                                /**
                                 * Type of data used in `Data`.
                                 *
                                 * @property _type
                                 * @readOnly
                                 * @private
                                 */
                                _type: "stacked",
                            
                                /**
                                 * Calculates the maximum and minimum values for the `Data`.
                                 *
                                 * @method _updateMinAndMax
                                 * @private
                                 */
                                _updateMinAndMax: function()
                                {
                                    var max = 0,
                                        min = 0,
                                        pos = 0,
                                        neg = 0,
                                        len = 0,
                                        i = 0,
                                        key,
                                        num,
                                        keys = this.get("keys"),
                                        setMin = this.get("setMin"),
                                        setMax = this.get("setMax");
                            
                                    for(key in keys)
                                    {
                                        if(keys.hasOwnProperty(key))
                                        {
                                            len = Math.max(len, keys[key].length);
                                        }
                                    }
                                    for(; i < len; ++i)
                                    {
                                        pos = 0;
                                        neg = 0;
                                        for(key in keys)
                                        {
                                            if(keys.hasOwnProperty(key))
                                            {
                                                num = keys[key][i];
                                                if(isNaN(num))
                                                {
                                                    continue;
                                                }
                                                if(num >= 0)
                                                {
                                                    pos += num;
                                                }
                                                else
                                                {
                                                    neg += num;
                                                }
                                            }
                                        }
                                        if(pos > 0)
                                        {
                                            max = Math.max(max, pos);
                                        }
                                        else
                                        {
                                            max = Math.max(max, neg);
                                        }
                                        if(neg < 0)
                                        {
                                            min = Math.min(min, neg);
                                        }
                                        else
                                        {
                                            min = Math.min(min, pos);
                                        }
                                    }
                                    this._actualMaximum = max;
                                    this._actualMinimum = min;
                                    if(setMax)
                                    {
                                        max = this._setMaximum;
                                    }
                                    if(setMin)
                                    {
                                        min = this._setMinimum;
                                    }
                                    this._roundMinAndMax(min, max, setMin, setMax);
                                }
                            };
                            
                            Y.StackedImpl = StackedImpl;