lib/yuilib/3.13.0/axis-numeric-base/axis-numeric-base.js

   1 /*
   2 YUI 3.13.0 (build 508226d)
   3 Copyright 2013 Yahoo! Inc. All rights reserved.
   4 Licensed under the BSD License.
   5 http://yuilibrary.com/license/
   6 */
   7
   8 YUI.add('axis-numeric-base', function (Y, NAME) {
   9
  10 /**
  11  * Provides functionality for the handling of numeric axis data for a chart.
  12  *
  13  * @module charts
  14  * @submodule axis-numeric-base
  15  */
  16 var Y_Lang = Y.Lang;
  17
  18 /**
  19  * NumericImpl contains logic for numeric data. NumericImpl is used by the following classes:
  20  * <ul>
  21  *      <li>{{#crossLink "NumericAxisBase"}}{{/crossLink}}</li>
  22  *      <li>{{#crossLink "NumericAxis"}}{{/crossLink}}</li>
  23  *  </ul>
  24  *
  25  * @class NumericImpl
  26  * @constructor
  27  * @submodule axis-numeric-base
  28  */
  29 function NumericImpl()
  30 {
  31 }
  32
  33 NumericImpl.NAME = "numericImpl";
  34
  35 NumericImpl.ATTRS = {
  36     /**
  37      * Indicates whether 0 should always be displayed.
  38      *
  39      * @attribute alwaysShowZero
  40      * @type Boolean
  41      */
  42     alwaysShowZero: {
  43         value: true
  44     },
  45
  46     /**
  47      * Method used for formatting a label. This attribute allows for the default label formatting method to overridden.
  48      * The method use would need to implement the arguments below and return a `String` or an `HTMLElement`. The default
  49      * implementation of the method returns a `String`. The output of this method will be rendered to the DOM using
  50      * `appendChild`. If you override the `labelFunction` method and return an html string, you will also need to override
  51      * the Data' `appendLabelFunction` to accept html as a `String`.
  52      * <dl>
  53      *      <dt>val</dt><dd>Label to be formatted. (`String`)</dd>
  54      *      <dt>format</dt><dd>Object containing properties used to format the label. (optional)</dd>
  55      * </dl>
  56      *
  57      * @attribute labelFunction
  58      * @type Function
  59      */
  60
  61     /**
  62      * Object containing properties used by the `labelFunction` to format a
  63      * label.
  64      *
  65      * @attribute labelFormat
  66      * @type Object
  67      */
  68     labelFormat: {
  69         value: {
  70             prefix: "",
  71             thousandsSeparator: "",
  72             decimalSeparator: "",
  73             decimalPlaces: "0",
  74             suffix: ""
  75         }
  76     },
  77
  78     /**
  79      *Indicates how to round unit values.
  80      *  <dl>
  81      *      <dt>niceNumber</dt><dd>Units will be smoothed based on the number of ticks and data range.</dd>
  82      *      <dt>auto</dt><dd>If the range is greater than 1, the units will be rounded.</dd>
  83      *      <dt>numeric value</dt><dd>Units will be equal to the numeric value.</dd>
  84      *      <dt>null</dt><dd>No rounding will occur.</dd>
  85      *  </dl>
  86      *
  87      * @attribute roundingMethod
  88      * @type String
  89      * @default niceNumber
  90      */
  91     roundingMethod: {
  92         value: "niceNumber"
  93     },
  94
  95     /**
  96      * Indicates the scaling for the chart. The default value is `linear`. For a logarithmic axis, set the value
  97      * to `logarithmic`.
  98      *
  99      * @attribute
 100      * @type String
 101      * @default linear
 102      */
 103     scaleType: {
 104         value: "linear"
 105     }
 106 };
 107
 108 NumericImpl.prototype = {
 109     /**
 110      * @method initializer
 111      * @private
 112      */
 113     initializer: function() {
 114         this.after("alwaysShowZeroChange", this._keyChangeHandler);
 115         this.after("roundingMethodChange", this._keyChangeHandler);
 116         this.after("scaleTypeChange", this._keyChangeHandler);
 117     },
 118
 119     /**
 120      * Formats a label based on the axis type and optionally specified format.
 121      *
 122      * @method
 123      * @param {Object} value
 124      * @param {Object} format Pattern used to format the value.
 125      * @return String
 126      */
 127     formatLabel: function(val, format)
 128     {
 129         if(format)
 130         {
 131             return Y.DataType.Number.format(val, format);
 132         }
 133         return val;
 134     },
 135
 136     /**
 137      * Returns the sum of all values per key.
 138      *
 139      * @method getTotalByKey
 140      * @param {String} key The identifier for the array whose values will be calculated.
 141      * @return Number
 142      */
 143     getTotalByKey: function(key)
 144     {
 145         var total = 0,
 146             values = this.getDataByKey(key),
 147             i = 0,
 148             val,
 149             len = values ? values.length : 0;
 150         for(; i < len; ++i)
 151         {
 152            val = parseFloat(values[i]);
 153            if(!isNaN(val))
 154            {
 155                 total += val;
 156            }
 157         }
 158         return total;
 159     },
 160
 161     /**
 162      * Returns the value corresponding to the origin on the axis.
 163      *
 164      * @method getOrigin
 165      * @return Number
 166      */
 167     getOrigin: function() {
 168         var origin = 0,
 169             min = this.get("minimum"),
 170             max = this.get("maximum");
 171         origin = Math.max(origin, min);
 172         origin = Math.min(origin, max);
 173         return origin;
 174     },
 175
 176     /**
 177      * Type of data used in `Data`.
 178      *
 179      * @property _type
 180      * @readOnly
 181      * @private
 182      */
 183     _type: "numeric",
 184
 185     /**
 186      * Helper method for getting a `roundingUnit` when calculating the minimum and maximum values.
 187      *
 188      * @method _getMinimumUnit
 189      * @param {Number} max Maximum number
 190      * @param {Number} min Minimum number
 191      * @param {Number} units Number of units on the axis
 192      * @return Number
 193      * @private
 194      */
 195     _getMinimumUnit:function(max, min, units)
 196     {
 197         return this._getNiceNumber(Math.ceil((max - min)/units));
 198     },
 199
 200     /**
 201      * Calculates a nice rounding unit based on the range.
 202      *
 203      * @method _getNiceNumber
 204      * @param {Number} roundingUnit The calculated rounding unit.
 205      * @return Number
 206      * @private
 207      */
 208     _getNiceNumber: function(roundingUnit)
 209     {
 210         var tempMajorUnit = roundingUnit,
 211             order = Math.ceil(Math.log(tempMajorUnit) * 0.4342944819032518),
 212             roundedMajorUnit = Math.pow(10, order),
 213             roundedDiff;
 214
 215         if (roundedMajorUnit / 2 >= tempMajorUnit)
 216         {
 217             roundedDiff = Math.floor((roundedMajorUnit / 2 - tempMajorUnit) / (Math.pow(10,order-1)/2));
 218             tempMajorUnit = roundedMajorUnit/2 - roundedDiff*Math.pow(10,order-1)/2;
 219         }
 220         else
 221         {
 222             tempMajorUnit = roundedMajorUnit;
 223         }
 224         if(!isNaN(tempMajorUnit))
 225         {
 226             return tempMajorUnit;
 227         }
 228         return roundingUnit;
 229
 230     },
 231
 232     /**
 233      * Calculates the maximum and minimum values for the `Data`.
 234      *
 235      * @method _updateMinAndMax
 236      * @private
 237      */
 238     _updateMinAndMax: function()
 239     {
 240         var data = this.get("data"),
 241             max,
 242             min,
 243             len,
 244             num,
 245             i = 0,
 246             setMax = this.get("setMax"),
 247             setMin = this.get("setMin");
 248         if(!setMax || !setMin)
 249         {
 250             if(data && data.length && data.length > 0)
 251             {
 252                 len = data.length;
 253                 for(; i < len; i++)
 254                 {
 255                     num = data[i];
 256                     if(isNaN(num))
 257                     {
 258                         max = setMax ? this._setMaximum : max;
 259                         min = setMin ? this._setMinimum : min;
 260                         continue;
 261                     }
 262
 263                     if(setMin)
 264                     {
 265                         min = this._setMinimum;
 266                     }
 267                     else if(min === undefined)
 268                     {
 269                         min = num;
 270                     }
 271                     else
 272                     {
 273                         min = Math.min(num, min);
 274                     }
 275                     if(setMax)
 276                     {
 277                         max = this._setMaximum;
 278                     }
 279                     else if(max === undefined)
 280                     {
 281                         max = num;
 282                     }
 283                     else
 284                     {
 285                         max = Math.max(num, max);
 286                     }
 287
 288                     this._actualMaximum = max;
 289                     this._actualMinimum = min;
 290                 }
 291             }
 292             if(this.get("scaleType") !== "logarithmic")
 293             {
 294                 this._roundMinAndMax(min, max, setMin, setMax);
 295             }
 296             else
 297             {
 298                 this._dataMaximum = max;
 299                 this._dataMinimum = min;
 300             }
 301         }
 302     },
 303
 304     /**
 305      * Rounds the mimimum and maximum values based on the `roundingUnit` attribute.
 306      *
 307      * @method _roundMinAndMax
 308      * @param {Number} min Minimum value
 309      * @param {Number} max Maximum value
 310      * @private
 311      */
 312     _roundMinAndMax: function(min, max, setMin, setMax)
 313     {
 314         var roundingUnit,
 315             minimumRange,
 316             minGreaterThanZero = min >= 0,
 317             maxGreaterThanZero = max > 0,
 318             dataRangeGreater,
 319             maxRound,
 320             minRound,
 321             topTicks,
 322             botTicks,
 323             tempMax,
 324             tempMin,
 325             units = this.getTotalMajorUnits() - 1,
 326             alwaysShowZero = this.get("alwaysShowZero"),
 327             roundingMethod = this.get("roundingMethod"),
 328             useIntegers = (max - min)/units >= 1;
 329         if(roundingMethod)
 330         {
 331             if(roundingMethod === "niceNumber")
 332             {
 333                 roundingUnit = this._getMinimumUnit(max, min, units);
 334                 if(minGreaterThanZero && maxGreaterThanZero)
 335                 {
 336                     if((alwaysShowZero || min < roundingUnit) && !setMin)
 337                     {
 338                         min = 0;
 339                         roundingUnit = this._getMinimumUnit(max, min, units);
 340                     }
 341                     else
 342                     {
 343                        min = this._roundDownToNearest(min, roundingUnit);
 344                     }
 345                     if(setMax)
 346                     {
 347                         if(!alwaysShowZero)
 348                         {
 349                             min = max - (roundingUnit * units);
 350                         }
 351                     }
 352                     else if(setMin)
 353                     {
 354                         max = min + (roundingUnit * units);
 355                     }
 356                     else
 357                     {
 358                         max = this._roundUpToNearest(max, roundingUnit);
 359                     }
 360                 }
 361                 else if(maxGreaterThanZero && !minGreaterThanZero)
 362                 {
 363                     if(alwaysShowZero)
 364                     {
 365                         topTicks = Math.round(units/((-1 * min)/max + 1));
 366                         topTicks = Math.max(Math.min(topTicks, units - 1), 1);
 367                         botTicks = units - topTicks;
 368                         tempMax = Math.ceil( max/topTicks );
 369                         tempMin = Math.floor( min/botTicks ) * -1;
 370
 371                         if(setMin)
 372                         {
 373                             while(tempMin < tempMax && botTicks >= 0)
 374                             {
 375                                 botTicks--;
 376                                 topTicks++;
 377                                 tempMax = Math.ceil( max/topTicks );
 378                                 tempMin = Math.floor( min/botTicks ) * -1;
 379                             }
 380                             //if there are any bottom ticks left calcualate the maximum by multiplying by the tempMin value
 381                             //if not, it's impossible to ensure that a zero is shown. skip it
 382                             if(botTicks > 0)
 383                             {
 384                                 max = tempMin * topTicks;
 385                             }
 386                             else
 387                             {
 388                                 max = min + (roundingUnit * units);
 389                             }
 390                         }
 391                         else if(setMax)
 392                         {
 393                             while(tempMax < tempMin && topTicks >= 0)
 394                             {
 395                                 botTicks++;
 396                                 topTicks--;
 397                                 tempMin = Math.floor( min/botTicks ) * -1;
 398                                 tempMax = Math.ceil( max/topTicks );
 399                             }
 400                             //if there are any top ticks left calcualate the minimum by multiplying by the tempMax value
 401                             //if not, it's impossible to ensure that a zero is shown. skip it
 402                             if(topTicks > 0)
 403                             {
 404                                 min = tempMax * botTicks * -1;
 405                             }
 406                             else
 407                             {
 408                                 min = max - (roundingUnit * units);
 409                             }
 410                         }
 411                         else
 412                         {
 413                             roundingUnit = Math.max(tempMax, tempMin);
 414                             roundingUnit = this._getNiceNumber(roundingUnit);
 415                             max = roundingUnit * topTicks;
 416                             min = roundingUnit * botTicks * -1;
 417                         }
 418                     }
 419                     else
 420                     {
 421                         if(setMax)
 422                         {
 423                             min = max - (roundingUnit * units);
 424                         }
 425                         else if(setMin)
 426                         {
 427                             max = min + (roundingUnit * units);
 428                         }
 429                         else
 430                         {
 431                             min = this._roundDownToNearest(min, roundingUnit);
 432                             max = this._roundUpToNearest(max, roundingUnit);
 433                         }
 434                     }
 435                 }
 436                 else
 437                 {
 438                     if(setMin)
 439                     {
 440                         if(alwaysShowZero)
 441                         {
 442                             max = 0;
 443                         }
 444                         else
 445                         {
 446                             max = min + (roundingUnit * units);
 447                         }
 448                     }
 449                     else if(!setMax)
 450                     {
 451                         if(alwaysShowZero || max === 0 || max + roundingUnit > 0)
 452                         {
 453                             max = 0;
 454                             roundingUnit = this._getMinimumUnit(max, min, units);
 455                             min = max - (roundingUnit * units);
 456                         }
 457                         else
 458                         {
 459                             min = this._roundDownToNearest(min, roundingUnit);
 460                             max = this._roundUpToNearest(max, roundingUnit);
 461                         }
 462                     }
 463                     else
 464                     {
 465                         min = max - (roundingUnit * units);
 466                     }
 467                 }
 468             }
 469             else if(roundingMethod === "auto")
 470             {
 471                 if(minGreaterThanZero && maxGreaterThanZero)
 472                 {
 473                     if((alwaysShowZero || min < (max-min)/units) && !setMin)
 474                     {
 475                         min = 0;
 476                     }
 477
 478                     roundingUnit = (max - min)/units;
 479                     if(useIntegers)
 480                     {
 481                         roundingUnit = Math.ceil(roundingUnit);
 482                         max = min + (roundingUnit * units);
 483                     }
 484                     else
 485                     {
 486                         max = min + Math.ceil(roundingUnit * units * 100000)/100000;
 487
 488                     }
 489                 }
 490                 else if(maxGreaterThanZero && !minGreaterThanZero)
 491                 {
 492                     if(alwaysShowZero)
 493                     {
 494                         topTicks = Math.round( units / ( (-1 * min) /max + 1) );
 495                         topTicks = Math.max(Math.min(topTicks, units - 1), 1);
 496                         botTicks = units - topTicks;
 497
 498                         if(useIntegers)
 499                         {
 500                             tempMax = Math.ceil( max/topTicks );
 501                             tempMin = Math.floor( min/botTicks ) * -1;
 502                             roundingUnit = Math.max(tempMax, tempMin);
 503                             max = roundingUnit * topTicks;
 504                             min = roundingUnit * botTicks * -1;
 505                         }
 506                         else
 507                         {
 508                             tempMax = max/topTicks;
 509                             tempMin = min/botTicks * -1;
 510                             roundingUnit = Math.max(tempMax, tempMin);
 511                             max = Math.ceil(roundingUnit * topTicks * 100000)/100000;
 512                             min = Math.ceil(roundingUnit * botTicks * 100000)/100000 * -1;
 513                         }
 514                     }
 515                     else
 516                     {
 517                         roundingUnit = (max - min)/units;
 518                         if(useIntegers)
 519                         {
 520                             roundingUnit = Math.ceil(roundingUnit);
 521                         }
 522                         min = Math.round(this._roundDownToNearest(min, roundingUnit) * 100000)/100000;
 523                         max = Math.round(this._roundUpToNearest(max, roundingUnit) * 100000)/100000;
 524                     }
 525                 }
 526                 else
 527                 {
 528                     roundingUnit = (max - min)/units;
 529                     if(useIntegers)
 530                     {
 531                         roundingUnit = Math.ceil(roundingUnit);
 532                     }
 533                     if(alwaysShowZero || max === 0 || max + roundingUnit > 0)
 534                     {
 535                         max = 0;
 536                         roundingUnit = (max - min)/units;
 537                         if(useIntegers)
 538                         {
 539                             Math.ceil(roundingUnit);
 540                             min = max - (roundingUnit * units);
 541                         }
 542                         else
 543                         {
 544                             min = max - Math.ceil(roundingUnit * units * 100000)/100000;
 545                         }
 546                     }
 547                     else
 548                     {
 549                         min = this._roundDownToNearest(min, roundingUnit);
 550                         max = this._roundUpToNearest(max, roundingUnit);
 551                     }
 552
 553                 }
 554             }
 555             else if(!isNaN(roundingMethod) && isFinite(roundingMethod))
 556             {
 557                 roundingUnit = roundingMethod;
 558                 minimumRange = roundingUnit * units;
 559                 dataRangeGreater = (max - min) > minimumRange;
 560                 minRound = this._roundDownToNearest(min, roundingUnit);
 561                 maxRound = this._roundUpToNearest(max, roundingUnit);
 562                 if(setMax)
 563                 {
 564                     min = max - minimumRange;
 565                 }
 566                 else if(setMin)
 567                 {
 568                     max = min + minimumRange;
 569                 }
 570                 else if(minGreaterThanZero && maxGreaterThanZero)
 571                 {
 572                     if(alwaysShowZero || minRound <= 0)
 573                     {
 574                         min = 0;
 575                     }
 576                     else
 577                     {
 578                         min = minRound;
 579                     }
 580                     max = min + minimumRange;
 581                 }
 582                 else if(maxGreaterThanZero && !minGreaterThanZero)
 583                 {
 584                     min = minRound;
 585                     max = maxRound;
 586                 }
 587                 else
 588                 {
 589                     if(alwaysShowZero || maxRound >= 0)
 590                     {
 591                         max = 0;
 592                     }
 593                     else
 594                     {
 595                         max = maxRound;
 596                     }
 597                     min = max - minimumRange;
 598                 }
 599             }
 600         }
 601         this._dataMaximum = max;
 602         this._dataMinimum = min;
 603     },
 604
 605     /**
 606      * Rounds a Number to the nearest multiple of an input. For example, by rounding
 607      * 16 to the nearest 10, you will receive 20. Similar to the built-in function Math.round().
 608      *
 609      * @method _roundToNearest
 610      * @param {Number} number Number to round
 611      * @param {Number} nearest Multiple to round towards.
 612      * @return Number
 613      * @private
 614      */
 615     _roundToNearest: function(number, nearest)
 616     {
 617         nearest = nearest || 1;
 618         var roundedNumber = Math.round(this._roundToPrecision(number / nearest, 10)) * nearest;
 619         return this._roundToPrecision(roundedNumber, 10);
 620     },
 621
 622     /**
 623      * Rounds a Number up to the nearest multiple of an input. For example, by rounding
 624      * 16 up to the nearest 10, you will receive 20. Similar to the built-in function Math.ceil().
 625      *
 626      * @method _roundUpToNearest
 627      * @param {Number} number Number to round
 628      * @param {Number} nearest Multiple to round towards.
 629      * @return Number
 630      * @private
 631      */
 632     _roundUpToNearest: function(number, nearest)
 633     {
 634         nearest = nearest || 1;
 635         return Math.ceil(this._roundToPrecision(number / nearest, 10)) * nearest;
 636     },
 637
 638     /**
 639      * Rounds a Number down to the nearest multiple of an input. For example, by rounding
 640      * 16 down to the nearest 10, you will receive 10. Similar to the built-in function Math.floor().
 641      *
 642      * @method _roundDownToNearest
 643      * @param {Number} number Number to round
 644      * @param {Number} nearest Multiple to round towards.
 645      * @return Number
 646      * @private
 647      */
 648     _roundDownToNearest: function(number, nearest)
 649     {
 650         nearest = nearest || 1;
 651         return Math.floor(this._roundToPrecision(number / nearest, 10)) * nearest;
 652     },
 653
 654     /**
 655      * Returns a coordinate corresponding to a data values.
 656      *
 657      * @method _getCoordFromValue
 658      * @param {Number} min The minimum for the axis.
 659      * @param {Number} max The maximum for the axis.
 660      * @param {length} length The distance that the axis spans.
 661      * @param {Number} dataValue A value used to ascertain the coordinate.
 662      * @param {Number} offset Value in which to offset the coordinates.
 663      * @param {Boolean} reverse Indicates whether the coordinates should start from
 664      * the end of an axis. Only used in the numeric implementation.
 665      * @return Number
 666      * @private
 667      */
 668     _getCoordFromValue: function(min, max, length, dataValue, offset, reverse)
 669     {
 670         var range,
 671             multiplier,
 672             valuecoord,
 673             isNumber = Y_Lang.isNumber;
 674         dataValue = parseFloat(dataValue);
 675         if(isNumber(dataValue))
 676         {
 677             if(this.get("scaleType") === "logarithmic" && min > 0)
 678             {
 679                 min = Math.log(min);
 680                 max = Math.log(max);
 681                 dataValue = Math.log(dataValue);
 682             }
 683             range = max - min;
 684             multiplier = length/range;
 685             valuecoord = (dataValue - min) * multiplier;
 686             valuecoord = reverse ? offset - valuecoord : offset + valuecoord;
 687         }
 688         else
 689         {
 690             valuecoord = NaN;
 691         }
 692         return valuecoord;
 693     },
 694
 695     /**
 696      * Rounds a number to a certain level of precision. Useful for limiting the number of
 697      * decimal places on a fractional number.
 698      *
 699      * @method _roundToPrecision
 700      * @param {Number} number Number to round
 701      * @param {Number} precision Multiple to round towards.
 702      * @return Number
 703      * @private
 704      */
 705     _roundToPrecision: function(number, precision)
 706     {
 707         precision = precision || 0;
 708         var decimalPlaces = Math.pow(10, precision);
 709         return Math.round(decimalPlaces * number) / decimalPlaces;
 710     }
 711 };
 712
 713 Y.NumericImpl = NumericImpl;
 714
 715 /**
 716  * NumericAxisBase manages numeric data for an axis.
 717  *
 718  * @class NumericAxisBase
 719  * @constructor
 720  * @extends AxisBase
 721  * @uses NumericImpl
 722  * @param {Object} config (optional) Configuration parameters.
 723  * @submodule axis-numeric-base
 724  */
 725 Y.NumericAxisBase = Y.Base.create("numericAxisBase", Y.AxisBase, [Y.NumericImpl]);
 726
 727
 728 }, '3.13.0', {"requires": ["axis-base"]});