topical media & game development

talk show tell print

mobile-query-three-bench-benchmark.js-benchmark.js / js



  /*!
   * Benchmark.js <http://benchmarkjs.com/>
   * Copyright 2010-2012 Mathias Bynens <http://mths.be/>
   * Based on JSLitmus.js, copyright Robert Kieffer <http://broofa.com/>
   * Modified by John-David Dalton <http://allyoucanleet.com/>
   * Available under MIT license <http://mths.be/mit>
   */
  ;(function(window, undefined) {
  
    
Detect free variable `define`

  
    var freeDefine = typeof define == 'function' &&
      typeof define.amd == 'object' && define.amd && define,
  
    
Detect free variable `exports`

  
    freeExports = typeof exports == 'object' && exports &&
      (typeof global == 'object' && global && global == global.global && (window = global), exports),
  
    
Detect free variable `require`

  
    freeRequire = typeof require == 'function' && require,
  
    
Used to assign each benchmark an incrimented id

  
    counter = 0,
  
    
Used to crawl all properties regardless of enumerability

  
    getAllKeys = Object.getOwnPropertyNames,
  
    
Used to get property descriptors

  
    getDescriptor = Object.getOwnPropertyDescriptor,
  
    
Used in case an object doesn't have its own method

  
    hasOwnProperty = {}.hasOwnProperty,
  
    
Used to check if an object is extensible

  
    isExtensible = Object.isExtensible || function() { return true; },
  
    
Used to check if an own property is enumerable

  
    propertyIsEnumerable = {}.propertyIsEnumerable,
  
    
Used to set property descriptors

  
    setDescriptor = Object.defineProperty,
  
    
Used to resolve a value's internal [[Class]]

  
    toString = {}.toString,
  
    
Used to integrity check compiled tests

  
    uid = 'uid' + (+new Date),
  
    
Used to avoid infinite recursion when methods call each other

  
    calledBy = {},
  
    
Used to avoid hz of Infinity

  
    divisors = {
      '1': 4096,
      '2': 512,
      '3': 64,
      '4': 8,
      '5': 0
    },
  
    
T-Distribution two-tailed critical values for 95% confidence http://www.itl.nist.gov/div898/handbook/eda/section3/eda3672.htm

  
    distribution = {
      '1':  12.706,'2':  4.303, '3':  3.182, '4':  2.776, '5':  2.571, '6':  2.447,
      '7':  2.365, '8':  2.306, '9':  2.262, '10': 2.228, '11': 2.201, '12': 2.179,
      '13': 2.16,  '14': 2.145, '15': 2.131, '16': 2.12,  '17': 2.11,  '18': 2.101,
      '19': 2.093, '20': 2.086, '21': 2.08,  '22': 2.074, '23': 2.069, '24': 2.064,
      '25': 2.06,  '26': 2.056, '27': 2.052, '28': 2.048, '29': 2.045, '30': 2.042,
      'infinity': 1.96
    },
  
    
Used to flag environments/features

  
    has = {
  
      
Detect Adobe AIR

  
      'air': isClassOf(window.runtime, 'ScriptBridgingProxyObject'),
  
      
Detect if `arguments` objects have the correct internal [[Class]] value

  
      'argumentsClass': isClassOf(arguments, 'Arguments'),
  
      
Detect if in a browser environment

  
      'browser': isHostType(window, 'document') && isHostType(window, 'navigator'),
  
      
Detect if strings support accessing characters by index

  
      'charByIndex':
        // IE 8 supports indexes on string literals but not string objects
       ('x'[0] + Object('x')[0]) == 'xx',
  
      
Detect if strings have indexes as own properties

  
      'charByOwnIndex':
        // Narwhal, Rhino, RingoJS, IE 8*, and Opera < 10.52 support indexes on
        // strings but don't detect them as own properties
        'x'[0] == 'x' && hasKey('x', '0'),
  
      
Detect if functions support decompilation

  
      'decompilation': !!(function() {
        try {
          // Safari 2.x removes commas in object literals
          // from Function#toString results
          // http://webk.it/11609
          // Firefox 3.6 and Opera 9.25 strip grouping
          // parentheses from Function#toString results
          // http://bugzil.la/559438
          return Function(
            'return (' + (function(x) { return { 'x': '' + (1 + x) + '', 'y': 0 }; }) + ')'
          )()(0).x === '1';
        } catch(e) { }
      }()),
  
      
Detect ES5+ property descriptor API

  
      'descriptors' : !!(function() {
        try {
          var o = {};
          return (setDescriptor(o, o, o), 'value' in getDescriptor(o, o));
        } catch(e) { }
      }()),
  
      
Detect ES5+ Object.getOwnPropertyNames()

  
      'getAllKeys': !!(function() {
        try {
          return /\bvalueOf\b/.test(getAllKeys(Object.prototype));
        } catch(e) { }
      }()),
  
      
Detect if Java is enabled/exposed

  
      'java': isClassOf(window.java, 'JavaPackage'),
  
      
Detect if the Timers API exists

  
      'timeout': isHostType(window, 'setTimeout') && isHostType(window, 'clearTimeout')
    },
  
    
Timer utility object used by `clock()` and `Deferred#resolve`. @private @type Object

  
    timer = {
  
     
The timer namespace object or constructor. @private @memberOf timer @type Function|Object

  
      'ns': Date,
  
     
Starts the deferred timer. @private @memberOf timer
parameter: {Object} deferred The deferred instance.

  
      'start': null, // lazy defined in `clock()`
  
     
Stops the deferred timer. @private @memberOf timer
parameter: {Object} deferred The deferred instance.

  
      'stop': null // lazy defined in `clock()`
    },
  
    
Shortcut for inverse results

  
    noArgumentsClass = !has.argumentsClass,
    noCharByIndex = !has.charByIndex,
    noCharByOwnIndex = !has.charByOwnIndex,
  
    
Math shortcuts

  
    abs   = Math.abs,
    floor = Math.floor,
    max   = Math.max,
    min   = Math.min,
    pow   = Math.pow,
    sqrt  = Math.sqrt;
  
    /*--------------------------------------------------------------------------*/
  
    
Benchmark constructor. @constructor
parameter: {String} name A name to identify the benchmark.
parameter: {Function|String} fn The test to benchmark.
parameter: {Object} [options={}] Options object. @example // basic usage (the `new` operator is optional) var bench = new Benchmark(fn); // or using a name first var bench = new Benchmark('foo', fn); // or with options var bench = new Benchmark('foo', fn, { // displayed by Benchmark#toString if `name` is not available 'id': 'xyz', // called when the benchmark starts running 'onStart': onStart, // called after each run cycle 'onCycle': onCycle, // called when aborted 'onAbort': onAbort, // called when a test errors 'onError': onError, // called when reset 'onReset': onReset, // called when the benchmark completes running 'onComplete': onComplete, // compiled/called before the test loop 'setup': setup, // compiled/called after the test loop 'teardown': teardown }); // or name and options var bench = new Benchmark('foo', { // a flag to indicate the benchmark is deferred 'deferred': true, // benchmark test function 'fn': function(deferred) { // call resolve() when the deferred test is finished deferred.resolve(); } }); // or options only var bench = new Benchmark({ // benchmark name 'name': 'foo', // benchmark test as a string 'fn': '[1,2,3,4].sort()' }); // a test's `this` binding is set to the benchmark instance var bench = new Benchmark('foo', function() { 'My name is '.concat(this.name); // My name is foo });

  
    function Benchmark(name, fn, options) {
      var me = this;
  
      // allow instance creation without the `new` operator
      if (me && me.constructor != Benchmark) {
        return new Benchmark(name, fn, options);
      }
      // juggle arguments
      if (isClassOf(name, 'Object')) {
        // 1 argument (options)
        options = name;
      }
      else if (isClassOf(name, 'Function')) {
        // 2 arguments (fn, options)
        options = fn;
        fn = name;
      }
      else if (isClassOf(fn, 'Object')) {
        // 2 arguments (name, options)
        options = fn;
        fn = null;
        me.name = name;
      }
      else {
        // 3 arguments (name, fn [, options])
        me.name = name;
      }
      setOptions(me, options);
      me.id || (me.id = ++counter);
      me.fn == null && (me.fn = fn);
      me.stats = extend({}, me.stats);
      me.times = extend({}, me.times);
    }
  
    
Deferred constructor. @constructor @memberOf Benchmark
parameter: {Object} bench The benchmark instance.

  
    function Deferred(bench) {
      var me = this;
      if (me && me.constructor != Deferred) {
        return new Deferred(bench);
      }
      me.benchmark = bench;
      clock(me);
    }
  
    
Event constructor. @constructor @memberOf Benchmark
parameter: {String|Object} type The event type.

  
    function Event(type) {
      var me = this;
      return (me && me.constructor != Event)
        ? new Event(type)
        : (type instanceof Event)
            ? type
            : extend(me, typeof type == 'string' ? { 'type': type } : type);
    }
  
    
Suite constructor. @constructor @memberOf Benchmark
parameter: {String} name A name to identify the suite.
parameter: {Object} [options={}] Options object. @example // basic usage (the `new` operator is optional) var suite = new Benchmark.Suite; // or using a name first var suite = new Benchmark.Suite('foo'); // or with options var suite = new Benchmark.Suite('foo', { // called when the suite starts running 'onStart': onStart, // called between running benchmarks 'onCycle': onCycle, // called when aborted 'onAbort': onAbort, // called when a test errors 'onError': onError, // called when reset 'onReset': onReset, // called when the suite completes running 'onComplete': onComplete });

  
    function Suite(name, options) {
      var me = this;
  
      // allow instance creation without the `new` operator
      if (me && me.constructor != Suite) {
        return new Suite(name, options);
      }
      // juggle arguments
      if (isClassOf(name, 'Object')) {
        // 1 argument (options)
        options = name;
      } else {
        // 2 arguments (name [, options])
        me.name = name;
      }
      setOptions(me, options);
    }
  
    /*--------------------------------------------------------------------------*/
  
    
Note: Some array methods have been implemented in plain JavaScript to avoid bugs in IE, Opera, Rhino, and Mobile Safari. IE compatibility mode and IE < 9 have buggy Array `shift()` and `splice()` functions that fail to remove the last element, `object[0]`, of array-like-objects even though the `length` property is set to `0`. The `shift()` method is buggy in IE 8 compatibility mode, while `splice()` is buggy regardless of mode in IE < 9 and buggy in compatibility mode in IE 9. In Opera < 9.50 and some older/beta Mobile Safari versions using `unshift()` generically to augment the `arguments` object will pave the value at index 0 without incrimenting the other values's indexes. github.com/documentcloud/underscore/issues/9 Rhino and environments it powers, like Narwhal and RingoJS, may have buggy Array `concat()`, `reverse()`, `shift()`, `slice()`, `splice()` and `unshift()` functions that make sparse arrays non-sparse by assigning the undefined indexes a value of undefined. github.com/mozilla/rhino/commit/702abfed3f8ca043b2636efd31c14ba7552603dd

  
  
    
Creates an array containing the elements of the host array followed by the elements of each argument in order. @memberOf Benchmark.Suite
returns: {Array} The new array.

  
    function concat() {
      var value,
          j = -1,
          length = arguments.length,
          result = slice.call(this),
          index = result.length;
  
      while (++j < length) {
        value = arguments[j];
        if (isClassOf(value, 'Array')) {
          for (var k = 0, l = value.length; k < l; k++, index++) {
            if (k in value) {
              result[index] = value[k];
            }
          }
        } else {
          result[index] = value;
        }
      }
      return result;
    }
  
    
Utility function used by `shift()`, `splice()`, and `unshift()`. @private
parameter: {Number} start The index to start inserting elements.
parameter: {Number} deleteCount The number of elements to delete from the insert point.
parameter: {Array} elements The elements to insert.
returns: {Array} An array of deleted elements.

  
    function insert(start, deleteCount, elements) {
      var deleteEnd = start + deleteCount,
          elementCount = elements ? elements.length : 0,
          index = start - 1,
          length = start + elementCount,
          object = this,
          result = [],
          tail = slice.call(object, deleteEnd);
  
      // delete elements from the array
      while (++index < deleteEnd) {
        if (index in object) {
          result[index - start] = object[index];
          delete object[index];
        }
      }
      // insert elements
      index = start - 1;
      while (++index < length) {
        object[index] = elements[index - start];
      }
      // append tail elements
      start = index--;
      length = (object.length >>> 0) - deleteCount + elementCount;
      while (++index < length) {
        if ((index - start) in tail) {
          object[index] = tail[index - start];
        } else {
          delete object[index];
        }
      }
      // delete excess elements
      deleteCount = deleteCount > elementCount ? deleteCount - elementCount : 0;
      while (deleteCount--) {
        delete object[length + deleteCount];
      }
      object.length = length;
      return result;
    }
  
    
Rearrange the host array's elements in reverse order. @memberOf Benchmark.Suite
returns: {Array} The reversed array.

  
    function reverse() {
      var upperIndex,
          value,
          index = -1,
          object = Object(this),
          length = object.length >>> 0,
          middle = floor(length / 2);
  
      if (length > 1) {
        while (++index < middle) {
          upperIndex = length - index - 1;
          value = upperIndex in object ? object[upperIndex] : uid;
          if (index in object) {
            object[upperIndex] = object[index];
          } else {
            delete object[upperIndex];
          }
          if (value != uid) {
            object[index] = value;
          } else {
            delete object[index];
          }
        }
      }
      return object;
    }
  
    
Removes the first element of the host array and returns it. @memberOf Benchmark.Suite
returns: {Mixed} The first element of the array.

  
    function shift() {
      return insert.call(this, 0, 1)[0];
    }
  
    
Creates an array of the host array's elements from the start index up to, but not including, the end index. @memberOf Benchmark.Suite
returns: {Array} The new array.

  
    function slice(start, end) {
      var index = -1,
          object = Object(this),
          length = object.length >>> 0,
          result = [];
  
      start = toInteger(start);
      start = start < 0 ? max(length + start, 0) : min(start, length);
      start--;
      end = end == null ? length : toInteger(end);
      end = end < 0 ? max(length + end, 0) : min(end, length);
  
      while ((++index, ++start) < end) {
        if (start in object) {
          result[index] = object[start];
        }
      }
      return result;
    }
  
    
Allows removing a range of elements and/or inserting elements into the host array. @memberOf Benchmark.Suite
returns: {Array} An array of removed elements.

  
    function splice(start, deleteCount) {
      var object = Object(this),
          length = object.length >>> 0;
  
      start = toInteger(start);
      start = start < 0 ? max(length + start, 0) : min(start, length);
      deleteCount = min(max(toInteger(deleteCount), 0), length - start);
      return insert.call(object, start, deleteCount, slice.call(arguments, 2));
    }
  
    
Converts the specified `value` to an integer. @private
parameter: {Mixed} value The value to convert.
returns: {Number} The resulting integer.

  
    function toInteger(value) {
      value = +value;
      return value === 0 || !isFinite(value) ? value || 0 : value - (value % 1);
    }
  
    
Appends arguments to the host array. @memberOf Benchmark.Suite
returns: {Number} The new length.

  
    function unshift() {
      var object = Object(this);
      insert.call(object, 0, 0, arguments);
      return object.length;
    }
  
    /*--------------------------------------------------------------------------*/
  
    
Executes a function, associated with a benchmark, synchronously or asynchronously. @private
parameter: {Object} options The options object.

  
    function call(options) {
      options || (options = {});
      var fn = options.fn;
  
      (!options.async && fn || function() {
        var bench = options.benchmark,
            ids = bench._timerIds || (bench._timerIds = []),
            index = ids.length;
  
        // under normal use there should only be one id at any time per benchmark
        ids.push(setTimeout(function() {
          ids.splice(index, 1);
          ids.length || delete bench._timerIds;
          fn();
        }, bench.delay * 1e3));
      })();
    }
  
    
Creates a function from the given arguments string and body. @private
parameter: {String} args The comma separated function arguments.
parameter: {String} body The function body.
returns: {Function} The new function.

  
    function createFunction() {
      // lazy define
      createFunction = function(args, body) {
        var anchor = freeDefine ? define.amd : Benchmark,
            prop = uid + 'createFunction';
  
        runScript((freeDefine ? 'define.amd.' : 'Benchmark.') + prop + '=function(' + args + '){' + body + '}');
        return [anchor[prop], delete anchor[prop]][0];
      };
      // fix JaegerMonkey bug
      // http://bugzil.la/639720
      createFunction = has.browser && (createFunction('', 'return"' + uid + '"') || noop)() == uid ? createFunction : Function;
      return createFunction.apply(null, arguments);
    }
  
    
Iterates over an object's properties, executing the `callback` for each. Callbacks may terminate the loop by explicitly returning `false`. @private
parameter: {Object} object The object to iterate over.
parameter: {Function} callback The function executed per own property.
parameter: {Object} options The options object.
returns: {Object} Returns the object iterated over.

  
    function forProps() {
      var forShadowed,
          skipSeen,
          forArgs = true,
          shadowed = ['constructor', 'hasOwnProperty', 'isPrototypeOf', 'propertyIsEnumerable', 'toLocaleString', 'toString', 'valueOf'];
  
      (function(enumFlag, key) {
        // must use a non-native constructor to catch the Safari 2 issue
        function Klass() { this.valueOf = 0; };
        Klass.prototype.valueOf = 0;
        // check various for-in bugs
        for (key in new Klass) {
          enumFlag += key == 'valueOf' ? 1 : 0;
        }
        // check if `arguments` objects have non-enumerable indexes
        for (key in arguments) {
          key == '0' && (forArgs = false);
        }
        // Safari 2 iterates over shadowed properties twice
        // http://replay.waybackmachine.org/20090428222941/http://tobielangel.com/2007/1/29/for-in-loop-broken-in-safari/
        skipSeen = enumFlag == 2;
        // IE < 9 incorrectly makes an object's properties non-enumerable if they have
        // the same name as other non-enumerable properties in its prototype chain.
        forShadowed = !enumFlag;
      }(0));
  
      // lazy define
      forProps = function(object, callback, options) {
        options || (options = {});
  
        var ctor,
            key,
            keys,
            skipCtor,
            done = !object,
            result = [object, object = Object(object)][0],
            which = options.which,
            allFlag = which == 'all',
            fn = callback,
            index = -1,
            iteratee = object,
            length = object.length,
            ownFlag = allFlag || which == 'own',
            seen = {},
            skipProto = isClassOf(object, 'Function'),
            thisArg = options.bind;
  
        object = Object(object);
  
        if (thisArg !== undefined) {
          callback = function(value, key, object) {
            return fn.call(thisArg, value, key, object);
          };
        }
        // iterate all properties
        if (allFlag && has.getAllKeys) {
          for (index = 0, keys = getAllKeys(object), length = keys.length; index < length; index++) {
            key = keys[index];
            if (callback(object[key], key, object) === false) {
              break;
            }
          }
        }
        // else iterate only enumerable properties
        else {
          for (key in object) {
            // Firefox < 3.6, Opera > 9.50 - Opera < 11.60, and Safari < 5.1
            // (if the prototype or a property on the prototype has been set)
            // incorrectly set a function's `prototype` property [[Enumerable]] value
            // to `true`. Because of this we standardize on skipping the `prototype`
            // property of functions regardless of their [[Enumerable]] value.
            if ((done =
                !(skipProto && key == 'prototype') &&
                !(skipSeen && (hasKey(seen, key) || !(seen[key] = true))) &&
                (!ownFlag || ownFlag && hasKey(object, key)) &&
                callback(object[key], key, object) === false)) {
              break;
            }
          }
          // in IE < 9 strings don't support accessing characters by index
          if (!done && (
              forArgs && isArguments(object) ||
              ((noCharByIndex || noCharByOwnIndex) && isClassOf(object, 'String') &&
                (iteratee = noCharByIndex ? object.split('') : object)))) {
            while (++index < length) {
              if ((done =
                  callback(iteratee[index], String(index), object) === false)) {
                break;
              }
            }
          }
          if (!done && forShadowed) {
            // Because IE < 9 can't set the `[[Enumerable]]` attribute of an existing
            // property and the `constructor` property of a prototype defaults to
            // non-enumerable, we manually skip the `constructor` property when we
            // think we are iterating over a `prototype` object.
            ctor = object.constructor;
            skipCtor = ctor && ctor.prototype && ctor.prototype.constructor === ctor;
            for (index = 0; index < 7; index++) {
              key = shadowed[index];
              if (!(skipCtor && key == 'constructor') &&
                  hasKey(object, key) &&
                  callback(object[key], key, object) === false) {
                break;
              }
            }
          }
        }
        return result;
      };
      return forProps.apply(null, arguments);
    }
  
    
Gets the critical value for the specified degrees of freedom. @private
parameter: {Number} df The degrees of freedom.
returns: {Number} The critical value.

  
    function getCriticalValue(df) {
      return distribution[Math.round(df) || 1] || distribution.infinity;
    }
  
    
Gets the name of the first argument from a function's source. @private
parameter: {Function} fn The function.
parameter: {String} altName A string used when the name of the first argument is unretrievable.
returns: {String} The argument name.

  
    function getFirstArgument(fn, altName) {
      return (!hasKey(fn, 'toString') &&
        (/^[\s(]*function[^(]*\(([^\s,)]+)/.exec(fn) || 0)[1]) || altName || '';
    }
  
    
Computes the arithmetic mean of a sample. @private
parameter: {Array} sample The sample.
returns: {Number} The mean.

  
    function getMean(sample) {
      return reduce(sample, function(sum, x) {
        return sum + x;
      }) / sample.length || 0;
    }
  
    
Gets the source code of a function. @private
parameter: {Function} fn The function.
parameter: {String} altSource A string used when a function's source code is unretrievable.
returns: {String} The function's source code.

  
    function getSource(fn, altSource) {
      var result = altSource;
      if (isStringable(fn)) {
        result = String(fn);
      } else if (has.decompilation) {
        // escape the `{` for Firefox 1
        result = (/^[^{]+\{([\s\S]*)}\s*/.exec(fn) || 0)[1];
      }
      return (result || '').replace(/^\s+|\s+/g, '');
    }
  
    
Checks if a value is an `arguments` object. @private
parameter: {Mixed} value The value to check.
returns: {Boolean} Returns `true` if the value is an `arguments` object, else `false`.

  
    function isArguments() {
      // lazy define
      isArguments = function(value) {
        return toString.call(value) == '[object Arguments]';
      };
      if (noArgumentsClass) {
        isArguments = function(value) {
          return hasKey(value, 'callee') &&
            !(propertyIsEnumerable && propertyIsEnumerable.call(value, 'callee'));
        };
      }
      return isArguments(arguments[0]);
    }
  
    
Checks if an object is of the specified class. @private
parameter: {Mixed} value The value to check.
parameter: {String} name The name of the class.
returns: {Boolean} Returns `true` if the value is of the specified class, else `false`.

  
    function isClassOf(value, name) {
      return value != null && toString.call(value) == '[object ' + name + ']';
    }
  
    
Host objects can return type values that are different from their actual data type. The objects we are concerned with usually return non-primitive types of object, function, or unknown. @private
parameter: {Mixed} object The owner of the property.
parameter: {String} property The property to check.
returns: {Boolean} Returns `true` if the property value is a non-primitive, else `false`.

  
    function isHostType(object, property) {
      var type = object != null ? typeof object[property] : 'number';
      return !/^(?:boolean|number|string|undefined)/.test(type) &&
        (type == 'object' ? !!object[property] : true);
    }
  
    
Checks if the specified `value` is an object created by the `Object` constructor. @private
parameter: {Mixed} value The value to check.
returns: {Boolean} Returns `true` if `value` is an object, else `false`.

  
    function isObject(value) {
      var ctor,
          result = !!value && toString.call(value) == '[object Object]';
  
      if (result && noArgumentsClass) {
        // avoid false positives for `arguments` objects in IE < 9
        result = !isArguments(value);
      }
      if (result) {
        // IE < 9 presents nodes like `Object` objects:
        // IE < 8 are missing the node's constructor property
        // IE 8 node constructors are typeof "object"
        ctor = value.constructor;
        // check if the constructor is `Object` as `Object instanceof Object` is `true`
        if ((result = isClassOf(ctor, 'Function') && ctor instanceof ctor)) {
          // assume objects created by the `Object` constructor have no inherited enumerable properties
          // (we assume there are no `Object.prototype` extensions)
          forProps(value, function(subValue, subKey) {
            result = subKey;
          });
          // An object's own properties are iterated before inherited properties.
          // If the last iterated key belongs to an object's own property then
          // there are no inherited enumerable properties.
          result = result === true || hasKey(value, result);
        }
      }
      return result;
    }
  
    
Checks if a value can be safely coerced to a string. @private
parameter: {Mixed} value The value to check.
returns: {Boolean} Returns `true` if the value can be coerced, else `false`.

  
    function isStringable(value) {
      return hasKey(value, 'toString') || isClassOf(value, 'String');
    }
  
    
Wraps a function and passes `this` to the original function as the first argument. @private
parameter: {Function} fn The function to be wrapped.
returns: {Function} The new function.

  
    function methodize(fn) {
      return function() {
        var args = [this];
        args.push.apply(args, arguments);
        return fn.apply(null, args);
      };
    }
  
    
A no-operation function. @private

  
    function noop() {
      // no operation performed
    }
  
    
A wrapper around require() to suppress `module missing` errors. @private
parameter: {String} id The module id.
returns: {Mixed} The exported module or `null`.

  
    function req(id) {
      try {
        return freeExports && freeRequire(id);
      } catch(e) { }
      return null;
    }
  
    
Runs a snippet of JavaScript via script injection. @private
parameter: {String} code The code to run.

  
    function runScript(code) {
      var anchor = freeDefine ? define.amd : Benchmark,
          script = document.createElement('script'),
          sibling = document.getElementsByTagName('script')[0],
          parent = sibling.parentNode,
          prop = uid + 'runScript',
          prefix = '(' + (freeDefine ? 'define.amd.' : 'Benchmark.') + prop + '||function(){})();';
  
      // Firefox 2.0.0.2 cannot use script injection as intended because it executes
      // asynchronously, but that's OK because script injection is only used to avoid
      // the previously commented JaegerMonkey bug.
      try {
        // remove the inserted script *before* running the code to avoid differences
        // in the expected script element count/order of the document.
        script.appendChild(document.createTextNode(prefix + code));
        anchor[prop] = function() { parent.removeChild(script); };
      } catch(e) {
        parent = parent.cloneNode(false);
        sibling = null;
        script.text = code;
      }
      parent.insertBefore(script, sibling);
      delete anchor[prop];
    }
  
    
A helper function for setting options/event handlers. @private
parameter: {Object} bench The benchmark instance.
parameter: {Object} [options={}] Options object.

  
    function setOptions(bench, options) {
      options = extend({}, bench.constructor.options, options);
      bench.options = forOwn(options, function(value, key) {
        if (value != null) {
          // add event listeners
          if (/^on[A-Z]/.test(key)) {
            forEach(key.split(' '), function(key) {
              bench.on(key.slice(2).toLowerCase(), value);
            });
          } else {
            bench[key] = deepClone(value);
          }
        }
      });
    }
  
    /*--------------------------------------------------------------------------*/
  
    
Handles cycling/completing the deferred benchmark. @memberOf Benchmark.Deferred

  
    function resolve() {
      var me = this,
          bench = me.benchmark;
  
      if (++me.cycles < bench.count) {
        // continue the test loop
        (bench._host || bench).compiled.call(me, timer);
      } else {
        timer.stop(me);
        call({
          'async': true,
          'benchmark': bench,
          'fn': function() {
            cycle({ 'benchmark': bench, 'deferred': me });
          }
        });
      }
    }
  
    /*--------------------------------------------------------------------------*/
  
    
A deep clone utility. @static @memberOf Benchmark
parameter: {Mixed} value The value to clone.
returns: {Mixed} The cloned value.

  
    function deepClone(value) {
      var accessor,
          circular,
          clone,
          ctor,
          descriptor,
          extensible,
          key,
          length,
          markerKey,
          parent,
          result,
          source,
          subIndex,
          data = { 'value': value },
          index = 0,
          marked = [],
          queue = { 'length': 0 },
          unmarked = [];
  
      
An easily detectable decorator for cloned values.

  
      function Marker(object) {
        this.raw = object;
      }
  
      
Gets an available marker key for the given object.

  
      function getMarkerKey(object) {
        // avoid collisions with existing keys
        var result = uid;
        while (object[result] && object[result].constructor != Marker) {
          result += 1;
        }
        return result;
      }
  
      
The callback used by `forProps()`.

  
      function propCallback(subValue, subKey) {
        // exit early to avoid cloning the marker
        if (subValue && subValue.constructor == Marker) {
          return;
        }
        // add objects to the queue
        if (subValue === Object(subValue)) {
          queue[queue.length++] = { 'key': subKey, 'parent': clone, 'source': value };
        }
        // assign non-objects
        else {
          clone[subKey] = subValue;
        }
      }
  
      do {
        key = data.key;
        parent = data.parent;
        source = data.source;
        clone = value = source ? source[key] : data.value;
        accessor = circular = descriptor = false;
  
        // create a basic clone to filter out functions, DOM elements, and
        // other non `Object` objects
        if (value === Object(value)) {
          // use custom deep clone function if available
          if (isClassOf(value.deepClone, 'Function')) {
            clone = value.deepClone();
          } else {
            ctor = value.constructor;
            switch (toString.call(value)) {
              case '[object Array]':
                clone = new ctor(value.length);
                break;
  
              case '[object Boolean]':
                clone = new ctor(value == true);
                break;
  
              case '[object Date]':
                clone = new ctor(+value);
                break;
  
              case '[object Object]':
                isObject(value) && (clone = new ctor);
                break;
  
              case '[object Number]':
              case '[object String]':
                clone = new ctor(value);
                break;
  
              case '[object RegExp]':
                clone = ctor(value.source,
                  (value.global     ? 'g' : '') +
                  (value.ignoreCase ? 'i' : '') +
                  (value.multiline  ? 'm' : ''));
            }
          }
          // continue clone if `value` doesn't have an accessor descriptor
          // http://es5.github.com/#x8.10.1
          if (clone && clone != value &&
              !(descriptor = source && has.descriptors && getDescriptor(source, key),
                accessor = descriptor && (descriptor.get || descriptor.set))) {
            // use an existing clone (circular reference)
            if ((extensible = isExtensible(value))) {
              markerKey = getMarkerKey(value);
              if (value[markerKey]) {
                circular = clone = value[markerKey].raw;
              }
            } else {
              // for frozen/sealed objects
              for (subIndex = 0, length = unmarked.length; subIndex < length; subIndex++) {
                data = unmarked[subIndex];
                if (data.object === value) {
                  circular = clone = data.clone;
                  break;
                }
              }
            }
            if (!circular) {
              // mark object to allow quickly detecting circular references and tie it to its clone
              if (extensible) {
                value[markerKey] = new Marker(clone);
                marked.push({ 'key': markerKey, 'object': value });
              } else {
                // for frozen/sealed objects
                unmarked.push({ 'clone': clone, 'object': value });
              }
              // iterate over object properties
              forProps(value, propCallback, { 'which': 'all' });
            }
          }
        }
        if (parent) {
          // for custom property descriptors
          if (accessor || (descriptor &&
              !(descriptor.configurable && descriptor.enumerable && descriptor.writable))) {
            descriptor.value && (descriptor.value = clone);
            setDescriptor(parent, key, descriptor);
          }
          // for default property descriptors
          else {
            parent[key] = clone;
          }
        } else {
          result = clone;
        }
      } while ((data = queue[index++]));
  
      // remove markers
      for (index = 0, length = marked.length; index < length; index++) {
        data = marked[index];
        delete data.object[data.key];
      }
      return result;
    }
  
    
An iteration utility for arrays and objects. Callbacks may terminate the loop by explicitly returning `false`. @static @memberOf Benchmark
parameter: {Array|Object} object The object to iterate over.
parameter: {Function} callback The function called per iteration.
parameter: {Object} thisArg The `this` binding for the callback function.
returns: {Array|Object} Returns the object iterated over.

  
    function each(object, callback, thisArg) {
      var fn = callback,
          index = -1,
          result = [object, object = Object(object)][0],
          origObject = object,
          length = object.length,
          isSnapshot = !!(object.snapshotItem && (length = object.snapshotLength)),
          isSplittable = (noCharByIndex || noCharByOwnIndex) && isClassOf(object, 'String'),
          isConvertable = isSnapshot || isSplittable || 'item' in object;
  
      // in Opera < 10.5 `hasKey(object, 'length')` returns `false` for NodeLists
      if (length === length >>> 0) {
        if (isConvertable) {
          // the third argument of the callback is the original non-array object
          callback = function(value, index) {
            return fn.call(this, value, index, origObject);
          };
          // in IE < 9 strings don't support accessing characters by index
          if (isSplittable) {
            object = object.split('');
          } else {
            object = [];
            while (++index < length) {
              // in Safari 2 `index in object` is always `false` for NodeLists
              object[index] = isSnapshot ? result.snapshotItem(index) : result[index];
            }
          }
        }
        forEach(object, callback, thisArg);
      } else {
        forOwn(object, callback, thisArg);
      }
      return result;
    }
  
    
Copies own/inherited properties of a source object to the destination object. @static @memberOf Benchmark
parameter: {Object} destination The destination object.
parameter: {Object} [source={}] The source object.
returns: {Object} The destination object.

  
    function extend(destination, source) {
      // Chrome < 14 incorrectly sets `destination` to `undefined` when we `delete arguments[0]`
      // http://code.google.com/p/v8/issues/detail?id=839
      destination = [destination, delete arguments[0]][0];
      forEach(arguments, function(source) {
        forProps(source, function(value, key) {
          destination[key] = value;
        });
      });
      return destination;
    }
  
    
A generic `Array#filter` like method. @static @memberOf Benchmark
parameter: {Array} array The array to iterate over.
parameter: {Function|String} callback The function/alias called per iteration.
parameter: {Object} thisArg The `this` binding for the callback function.
returns: {Array} A new array of values that passed callback filter. @example // get odd numbers Benchmark.filter([1, 2, 3, 4, 5], function(n) { return n % 2; }); // -> [1, 3, 5]; // get fastest benchmarks Benchmark.filter(benches, 'fastest'); // get slowest benchmarks Benchmark.filter(benches, 'slowest'); // get benchmarks that completed without erroring Benchmark.filter(benches, 'successful');

  
    function filter(array, callback, thisArg) {
      var result;
  
      if (callback == 'successful') {
        // callback to exclude those that are errored, unrun, or have hz of Infinity
        callback = function(bench) { return bench.cycles && isFinite(bench.hz); };
      }
      else if (callback == 'fastest' || callback == 'slowest') {
        // get successful, sort by period + margin of error, and filter fastest/slowest
        result = filter(array, 'successful').sort(function(a, b) {
          a = a.stats; b = b.stats;
          return (a.mean + a.moe > b.mean + b.moe ? 1 : -1) * (callback == 'fastest' ? 1 : -1);
        });
        result = filter(result, function(bench) {
          return result[0].compare(bench) == 0;
        });
      }
      return result || reduce(array, function(result, value, index) {
        return callback.call(thisArg, value, index, array) ? (result.push(value), result) : result;
      }, []);
    }
  
    
A generic `Array#forEach` like method. Callbacks may terminate the loop by explicitly returning `false`. @static @memberOf Benchmark
parameter: {Array} array The array to iterate over.
parameter: {Function} callback The function called per iteration.
parameter: {Object} thisArg The `this` binding for the callback function.
returns: {Array} Returns the array iterated over.

  
    function forEach(array, callback, thisArg) {
      var fn = callback,
          index = -1,
          length = (array = Object(array)).length >>> 0;
  
      if (thisArg !== undefined) {
        callback = function(value, index, array) {
          return fn.call(thisArg, value, index, array);
        };
      }
      while (++index < length) {
        if (index in array &&
            callback(array[index], index, array) === false) {
          break;
        }
      }
      return array;
    }
  
    
Iterates over an object's own properties, executing the `callback` for each. Callbacks may terminate the loop by explicitly returning `false`. @static @memberOf Benchmark
parameter: {Object} object The object to iterate over.
parameter: {Function} callback The function executed per own property.
parameter: {Object} thisArg The `this` binding for the callback function.
returns: {Object} Returns the object iterated over.

  
    function forOwn(object, callback, thisArg) {
      return forProps(object, callback, { 'bind': thisArg, 'which': 'own' });
    }
  
    
Converts a number to a more readable comma-separated string representation. @static @memberOf Benchmark
parameter: {Number} number The number to convert.
returns: {String} The more readable string representation.

  
    function formatNumber(number) {
      number = String(number).split('.');
      return number[0].replace(/(?=(?:\d{3})+)(?!\b)/g, ',') +
        (number[1] ? '.' + number[1] : '');
    }
  
    
Checks if an object has the specified key as a direct property. @static @memberOf Benchmark
parameter: {Object} object The object to check.
parameter: {String} key The key to check for.
returns: {Boolean} Returns `true` if key is a direct property, else `false`.

  
    function hasKey() {
      // lazy define for worst case fallback (not as accurate)
      hasKey = function(object, key) {
        var parent = object != null && (object.constructor || Object).prototype;
        return !!parent && key in Object(object) && !(key in parent && object[key] === parent[key]);
      };
      // for modern browsers
      if (isClassOf(hasOwnProperty, 'Function')) {
        hasKey = function(object, key) {
          return object != null && hasOwnProperty.call(object, key);
        };
      }
      // for Safari 2
      else if ({}.__proto__ == Object.prototype) {
        hasKey = function(object, key) {
          var result = false;
          if (object != null) {
            object = Object(object);
            object.__proto__ = [object.__proto__, object.__proto__ = null, result = key in object][0];
          }
          return result;
        };
      }
      return hasKey.apply(this, arguments);
    }
  
    
A generic `Array#indexOf` like method. @static @memberOf Benchmark
parameter: {Array} array The array to iterate over.
parameter: {Mixed} value The value to search for.
parameter: {Number} [fromIndex=0] The index to start searching from.
returns: {Number} The index of the matched value or `-1`.

  
    function indexOf(array, value, fromIndex) {
      var index = toInteger(fromIndex),
          length = (array = Object(array)).length >>> 0;
  
      index = (index < 0 ? max(0, length + index) : index) - 1;
      while (++index < length) {
        if (index in array && value === array[index]) {
          return index;
        }
      }
      return -1;
    }
  
    
Modify a string by replacing named tokens with matching object property values. @static @memberOf Benchmark
parameter: {String} string The string to modify.
parameter: {Object} object The template object.
returns: {String} The modified string.

  
    function interpolate(string, object) {
      forOwn(object, function(value, key) {
        string = string.replace(RegExp('#\\{' + key + '\\}', 'g'), value);
      });
      return string;
    }
  
    
Invokes a method on all items in an array. @static @memberOf Benchmark
parameter: {Array} benches Array of benchmarks to iterate over.
parameter: {String|Object} name The name of the method to invoke OR options object.
parameter: {Mixed} [arg1, arg2, ...] Arguments to invoke the method with.
returns: {Array} A new array of values returned from each method invoked. @example // invoke `reset` on all benchmarks Benchmark.invoke(benches, 'reset'); // invoke `emit` with arguments Benchmark.invoke(benches, 'emit', 'complete', listener); // invoke `run(true)`, treat benchmarks as a queue, and register invoke callbacks Benchmark.invoke(benches, { // invoke the `run` method 'name': 'run', // pass a single argument 'args': true, // treat as queue, removing benchmarks from front of `benches` until empty 'queued': true, // called before any benchmarks have been invoked. 'onStart': onStart, // called between invoking benchmarks 'onCycle': onCycle, // called after all benchmarks have been invoked. 'onComplete': onComplete });

  
    function invoke(benches, name) {
      var args,
          bench,
          queued,
          index = -1,
          options = { 'onStart': noop, 'onCycle': noop, 'onComplete': noop },
          result = map(benches, function(bench) { return bench; });
  
      
Checks if invoking `run` with asynchronous cycles.

  
      function isAsync(object) {
        var async = args[0] && args[0].async;
        return isRun(object) && (async == null ? object.options.async : async) && has.timeout;
      }
  
      
Checks if invoking `run` on a benchmark instance.

  
      function isRun(object) {
        // avoid using `instanceof` here because of IE memory leak issues with host objects
        return Object(object).constructor == Benchmark && name == 'run';
      }
  
      
Checks if invoking `run` with synchronous cycles.

  
      function isSync(object) {
        // if not asynchronous or deferred
        return !isAsync(object) && !(isRun(object) && object.defer);
      }
  
      
Executes the method and if synchronous, fetches the next bench.

  
      function execute() {
        var listeners,
            sync = isSync(bench);
  
        if (!sync) {
          // use `getNext` as a listener
          bench.on('complete', getNext);
          listeners = bench.events.complete;
          listeners.splice(0, 0, listeners.pop());
        }
        // execute method
        result[index] = isClassOf(bench && bench[name], 'Function') ? bench[name].apply(bench, args) : undefined;
        // if synchronous return true until finished
        return sync && getNext();
      }
  
      
Fetches the next bench or executes `onComplete` callback.

  
      function getNext() {
        var last = bench,
            sync = isSync(last);
  
        if (!sync) {
          last.removeListener('complete', getNext);
          last.emit('complete');
        }
        // choose next benchmark if not exiting early
        if (options.onCycle.call(benches, Event('cycle'), last) !== false && raiseIndex() !== false) {
          bench = queued ? benches[0] : result[index];
          if (!isSync(bench)) {
            call({ 'async': isAsync(bench), 'benchmark': bench, 'fn': execute });
          }
          else if (!sync) {
            // resume synchronous execution
            while (execute()) { }
          }
          else {
            // continue synchronous execution
            return true;
          }
        } else {
          options.onComplete.call(benches, Event('complete'), last);
        }
        // when async the `return false` will cancel the rest of the "complete"
        // listeners because they were called above and when synchronous it will
        // exit the while-loop
        return false;
      }
  
      
Raises `index` to the next defined index or returns `false`.

  
      function raiseIndex() {
        var length = result.length;
        // if queued then remove the previous bench and subsequent skipped non-entries
        if (queued) {
          do {
            ++index > 0 && shift.call(benches);
          } while ((length = benches.length) && !('0' in benches));
        }
        else {
          while (++index < length && !(index in result)) { }
        }
        // if we reached the last index then return `false`
        return (queued ? length : index < length) ? index : (index = false);
      }
  
      // juggle arguments
      if (isClassOf(name, 'String')) {
        // 2 arguments (array, name)
        args = slice.call(arguments, 2);
      } else {
        // 2 arguments (array, options)
        options = extend(options, name);
        name = options.name;
        args = isClassOf(args = 'args' in options ? options.args : [], 'Array') ? args : [args];
        queued = options.queued;
      }
      // start iterating over the array
      if (raiseIndex() !== false) {
        bench = result[index];
        options.onStart.call(benches, Event('start'), bench);
  
        // end early if the suite was aborted in an "onStart" listener
        if (benches.aborted && benches.constructor == Suite && name == 'run') {
          options.onCycle.call(benches, Event('cycle'), bench);
          options.onComplete.call(benches, Event('complete'), bench);
        }
        // else start
        else {
          if (isAsync(bench)) {
            call({ 'async': true, 'benchmark': bench, 'fn': execute });
          } else {
            while (execute()) { }
          }
        }
      }
      return result;
    }
  
    
Creates a string of joined array values or object key-value pairs. @static @memberOf Benchmark
parameter: {Array|Object} object The object to operate on.
parameter: {String} [separator1=','] The separator used between key-value pairs.
parameter: {String} [separator2=': '] The separator used between keys and values.
returns: {String} The joined result.

  
    function join(object, separator1, separator2) {
      var result = [],
          length = (object = Object(object)).length,
          arrayLike = length === length >>> 0;
  
      separator2 || (separator2 = ': ');
      each(object, function(value, key) {
        result.push(arrayLike ? value : key + separator2 + value);
      });
      return result.join(separator1 || ',');
    }
  
    
A generic `Array#map` like method. @static @memberOf Benchmark
parameter: {Array} array The array to iterate over.
parameter: {Function} callback The function called per iteration.
parameter: {Object} thisArg The `this` binding for the callback function.
returns: {Array} A new array of values returned by the callback.

  
    function map(array, callback, thisArg) {
      return reduce(array, function(result, value, index) {
        result[index] = callback.call(thisArg, value, index, array);
        return result;
      }, Array(Object(array).length >>> 0));
    }
  
    
Retrieves the value of a specified property from all items in an array. @static @memberOf Benchmark
parameter: {Array} array The array to iterate over.
parameter: {String} property The property to pluck.
returns: {Array} A new array of property values.

  
    function pluck(array, property) {
      return map(array, function(object) {
        return object == null ? undefined : object[property];
      });
    }
  
    
A generic `Array#reduce` like method. @static @memberOf Benchmark
parameter: {Array} array The array to iterate over.
parameter: {Function} callback The function called per iteration.
parameter: {Mixed} accumulator Initial value of the accumulator.
returns: {Mixed} The accumulator.

  
    function reduce(array, callback, accumulator) {
      var noaccum = arguments.length < 3;
      forEach(array, function(value, index) {
        accumulator = noaccum ? (noaccum = 0, value) : callback(accumulator, value, index, array);
      });
      return accumulator;
    }
  
    /*--------------------------------------------------------------------------*/
  
    
Aborts all benchmarks in the suite. @name abort @memberOf Benchmark.Suite
returns: {Object} The suite instance.

  
    function abortSuite() {
      var me = this;
  
      if (me.running) {
        calledBy.abortSuite = true;
        me.reset();
        delete calledBy.abortSuite;
  
        me.aborted = true;
        !calledBy.resetSuite && invoke(me, 'abort');
        me.emit('abort');
      }
      return me;
    }
  
    
Adds a test to the benchmark suite. @memberOf Benchmark.Suite
parameter: {String} name A name to identify the benchmark.
parameter: {Function|String} fn The test to benchmark.
parameter: {Object} [options={}] Options object.
returns: {Object} The benchmark instance. @example // basic usage suite.add(fn); // or using a name first suite.add('foo', fn); // or with options suite.add('foo', fn, { 'onCycle': onCycle, 'onComplete': onComplete });

  
    function add(name, fn, options) {
      var me = this,
          bench = Benchmark(name, fn, options);
  
      me.push(bench);
      me.emit('add', bench);
      return me;
    }
  
    
Creates a new suite with cloned benchmarks. @name clone @memberOf Benchmark.Suite
parameter: {Object} options Options object to overwrite cloned options.
returns: {Object} The new suite instance.

  
    function cloneSuite(options) {
      var me = this,
          result = new me.constructor(extend({}, me.options, options));
  
      // copy own properties
      forOwn(me, function(value, key) {
        if (!hasKey(result, key)) {
          result[key] = value && isClassOf(value.clone, 'Function') ? value.clone() : deepClone(value);
        }
      });
      return result;
    }
  
    
An `Array#filter` like method. @name filter @memberOf Benchmark.Suite
parameter: {Function|String} callback The function/alias called per iteration.
returns: {Object} A new suite of benchmarks that passed callback filter.

  
    function filterSuite(callback) {
      var me = this,
          result = new me.constructor;
  
      result.push.apply(result, filter(me, callback));
      return result;
    }
  
    
Resets all benchmarks in the suite. @name reset @memberOf Benchmark.Suite
returns: {Object} The suite instance.

  
    function resetSuite() {
      var me = this,
          notAborting = !calledBy.abortSuite;
  
      if (me.running && notAborting) {
        calledBy.resetSuite = true;
        me.abort();
        delete calledBy.resetSuite;
        me.aborted = false;
      }
      else if (me.aborted !== false || me.running !== false) {
        me.aborted = me.running = false;
        notAborting && invoke(me, 'reset');
        me.emit('reset');
      }
      return me;
    }
  
    
Runs the suite. @name run @memberOf Benchmark.Suite
parameter: {Object} [options={}] Options object.
returns: {Object} The suite instance. @example // basic usage suite.run(); // or with options suite.run({ 'async': true, 'queued': true });

  
    function runSuite(options) {
      var me = this,
          benches = [];
  
      me.reset();
      me.running = true;
      options || (options = {});
  
      invoke(me, {
        'name': 'run',
        'args': options,
        'queued': options.queued,
        'onStart': function(event, bench) {
          me.emit('start', bench);
        },
        'onCycle': function(event, bench) {
          if (bench.error) {
            me.emit('error', bench);
          } else if (bench.cycles) {
            benches.push(bench);
          }
          return !me.aborted && me.emit('cycle', bench);
        },
        'onComplete': function(event, bench) {
          me.running = false;
          me.emit('complete', bench);
        }
      });
      return me;
    }
  
    /*--------------------------------------------------------------------------*/
  
    
Registers a single listener for the specified event type(s). @memberOf Benchmark, Benchmark.Suite
parameter: {String} type The event type.
parameter: {Function} listener The function called when the event occurs.
returns: {Object} The benchmark instance. @example // register a listener for an event type bench.addListener('cycle', listener); // register a listener for multiple event types bench.addListener('start cycle', listener);

  
    function addListener(type, listener) {
      var me = this,
          events = me.events || (me.events = {});
  
      forEach(type.split(' '), function(type) {
        (events[type] || (events[type] = [])).push(listener);
      });
      return me;
    }
  
    
Executes all registered listeners of the specified event type. @memberOf Benchmark, Benchmark.Suite
parameter: {String|Object} type The event type or object.
returns: {Boolean} Returns `true` if all listeners were executed, else `false`.

  
    function emit(type) {
      var me = this,
          event = Event(type),
          args = (arguments[0] = event, arguments),
          events = me.events,
          listeners = events && events[event.type] || [],
          result = true;
  
      forEach(listeners.slice(), function(listener) {
        return (result = listener.apply(me, args) !== false);
      });
      return result;
    }
  
    
Unregisters a single listener for the specified event type(s). @memberOf Benchmark, Benchmark.Suite
parameter: {String} type The event type.
parameter: {Function} listener The function to unregister.
returns: {Object} The benchmark instance. @example // unregister a listener for an event type bench.removeListener('cycle', listener); // unregister a listener for multiple event types bench.removeListener('start cycle', listener);

  
    function removeListener(type, listener) {
      var me = this,
          events = me.events;
  
      forEach(type.split(' '), function(type) {
        var listeners = events && events[type] || [],
            index = indexOf(listeners, listener);
        if (index > -1) {
          listeners.splice(index, 1);
        }
      });
      return me;
    }
  
    
Unregisters all listeners or those for the specified event type(s). @memberOf Benchmark, Benchmark.Suite
parameter: {String} type The event type.
returns: {Object} The benchmark instance. @example // unregister all listeners bench.removeAllListeners(); // unregister all listeners for an event type bench.removeAllListeners('cycle'); // unregister all listeners for multiple event types bench.removeAllListeners('start cycle complete');

  
    function removeAllListeners(type) {
      var me = this,
          events = me.events;
  
      forEach(type ? type.split(' ') : events, function(type) {
        (events && events[type] || []).length = 0;
      });
      return me;
    }
  
    /*--------------------------------------------------------------------------*/
  
    
Aborts the benchmark without recording times. @memberOf Benchmark
returns: {Object} The benchmark instance.

  
    function abort() {
      var me = this;
  
      if (me.running) {
        if (has.timeout) {
          forEach(me._timerIds || [], clearTimeout);
          delete me._timerIds;
        }
        // avoid infinite recursion
        calledBy.abort = true;
        me.reset();
        delete calledBy.abort;
  
        me.aborted = true;
        me.emit('abort');
      }
      return me;
    }
  
    
Creates a new benchmark using the same test and options. @memberOf Benchmark
parameter: {Object} options Options object to overwrite cloned options.
returns: {Object} The new benchmark instance. @example var bizarro = bench.clone({ 'name': 'doppelganger' });

  
    function clone(options) {
      var me = this,
          result = new me.constructor(extend({}, me, options));
  
      // correct the `options` object
      result.options = extend({}, me.options, options);
  
      // copy own custom properties
      forOwn(me, function(value, key) {
        if (!hasKey(result, key)) {
          result[key] = deepClone(value);
        }
      });
      return result;
    }
  
    
Determines if a benchmark is faster than another. @memberOf Benchmark
parameter: {Object} other The benchmark to compare.
returns: {Number} Returns `-1` if slower, `1` if faster, and `0` if indeterminate.

  
    function compare(other) {
      // unpaired two-sample t-test assuming equal variance
      // http://en.wikipedia.org/wiki/Student's_t-test
      // http://www.chem.utoronto.ca/coursenotes/analsci/StatsTutorial/12tailed.html
      var a = this.stats,
          b = other.stats,
          df = a.size + b.size - 2,
          pooled = (((a.size - 1) * a.variance) + ((b.size - 1) * b.variance)) / df,
          tstat = (a.mean - b.mean) / sqrt(pooled * (1 / a.size + 1 / b.size)),
          near = abs(1 - a.mean / b.mean) < 0.055 && a.rme < 3 && b.rme < 3;
  
      // check if the means aren't close and the t-statistic is significant
      // (a larger `mean` indicates a slower benchmark)
      return !near && abs(tstat) > getCriticalValue(df) ? (tstat > 0 ? -1 : 1) : 0;
    }
  
    
Reset properties and abort if running. @memberOf Benchmark
returns: {Object} The benchmark instance.

  
    function reset() {
      var changed,
          pair,
          me = this,
          source = extend({}, me.constructor.prototype, me.options),
          pairs = [[source, me]];
  
      if (me.running && !calledBy.abort) {
        // no worries, `reset()` is called within `abort()`
        me.abort();
        me.aborted = source.aborted;
      }
      else {
        // a non-recursive solution to check if properties have changed
        // http://www.jslab.dk/articles/non.recursive.preorder.traversal.part4
        while ((pair = pairs.pop())) {
          forOwn(pair[0], function(value, key) {
            var other = pair[1][key];
            if (value && isClassOf(value, 'Object')) {
              pairs.push([value, other]);
            }
            else if (value !== other && !(value == null || isClassOf(value, 'Function'))) {
              pair[1][key] = value;
              changed = true;
            }
          });
        }
        if (changed) {
          me.emit('reset');
        }
      }
      return me;
    }
  
    
Displays relevant benchmark information when coerced to a string. @name toString @memberOf Benchmark
returns: {String} A string representation of the benchmark instance.

  
    function toStringBench() {
      var me = this,
          error = me.error,
          hz = me.hz,
          id = me.id,
          stats = me.stats,
          size = stats.size,
          pm = has.java ? '+/-' : '\xb1',
          result = me.name || (typeof id == 'number' ? '<Test #' + id + '>' : id);
  
      if (error) {
        result += ': ' + join(error);
      } else {
        result += ' x ' + formatNumber(hz.toFixed(hz < 100 ? 2 : 0)) + ' ops/sec ' + pm +
          stats.rme.toFixed(2) + '% (' + size + ' run' + (size == 1 ? '' : 's') + ' sampled)';
      }
      return result;
    }
  
    /*--------------------------------------------------------------------------*/
  
    
Clocks the time taken to execute a test per cycle (secs). @private
parameter: {Object} bench The benchmark instance.
returns: {Number} The time taken.

  
    function clock() {
      var applet,
          options = Benchmark.options,
          template = { 'begin': 's=new n', 'end': 'r=(new n-s)/1e3', 'uid': uid },
          timers = [{ 'ns': timer.ns, 'res': max(0.0015, getRes('ms')), 'unit': 'ms' }];
  
      // lazy define for hi-res timers
      clock = function(bench) {
        var deferred = bench instanceof Deferred && [bench, bench = bench.benchmark][0],
            host = bench._host || bench,
            fn = host.fn,
            fnArg = deferred ? getFirstArgument(fn, 'deferred') : '',
            stringable = isStringable(fn),
            decompilable = has.decompilation || stringable,
            source = {
              'setup': getSource(host.setup, preprocess('m.setup()')),
              'fn': getSource(fn, preprocess('f$(' + fnArg + ')')),
              'fnArg': fnArg,
              'teardown': getSource(host.teardown, preprocess('m.teardown()'))
            },
            compiled = host.compiled,
            count = host.count = bench.count,
            id = host.id,
            isEmpty = !(source.fn || stringable),
            name = host.name || (typeof id == 'number' ? '<Test #' + id + '>' : id),
            ns = timer.ns,
            result = 0;
  
        // init `minTime` if needed
        bench.minTime = host.minTime || (host.minTime = host.options.minTime = options.minTime);
  
        // repair nanosecond timer
        // (some Chrome builds erase the `ns` variable after millions of executions)
        if (applet) {
          try {
            ns.nanoTime();
          } catch(e) {
            // use non-element to avoid issues with libs that augment them
            ns = timer.ns = new applet.Packages.nano;
          }
        }
  
        if(!compiled) {
          // compile in setup/teardown functions and the test loop
          compiled = host.compiled = createFunction(preprocess('t'), interpolate(
            preprocess(deferred
              ? 'var d=this,#{fnArg}=d,r=d.resolve,m=(m=d.benchmark)._host||m,f=m.fn;' +
                'if(!d.cycles){d.resolve=function(){d.resolve=r;r.call(d);' +
                'if(d.cycles==m.count){#{teardown}\n}};#{setup}\nt.start(d);}#{fn}\nreturn{}'
              : 'var r,s,m=this,f=m.fn,i=m.count,n=t.ns;#{setup}\n#{begin};' +
                'while(i--){#{fn}\n}#{end};#{teardown}\nreturn{elapsed:r,uid:"#{uid}"}'),
            source
          ));
  
          try {
            if (isEmpty) {
              // Firefox may remove dead code from Function#toString results
              // http://bugzil.la/536085
              throw new Error('The test, ' + name + ', is empty. This may be the result of dead code removal.');
            }
            else if (!deferred) {
              // pretest to determine if compiled code is exits early, usually by a
              // rogue `return` statement, by checking for a return object with the uid
              host.count = 1;
              compiled = (compiled.call(host, timer) || {}).uid == uid && compiled;
              host.count = count;
            }
          } catch(e) {
            compiled = false;
            bench.error = e || new Error(String(e));
            host.count = count;
          }
          // fallback when a test exits early or errors during pretest
          if (decompilable && !compiled && !deferred && !isEmpty) {
            compiled = createFunction(preprocess('t'), interpolate(
              preprocess((bench.error && !stringable
                ? 'var r,s,m=this,f=m.fn,i=m.count'
                : 'function f$(){#{fn}\n}var r,s,i=this.count'
              ) + ',n=t.ns;#{setup}\n#{begin};while(i--){f$()}#{end};#{teardown}\nreturn{elapsed:r}'),
              source
            ));
  
            try {
              // pretest one more time to check for errors
              host.count = 1;
              compiled.call(host, timer);
              host.compiled = compiled;
              host.count = count;
              delete bench.error;
            }
            catch(e) {
              host.count = count;
              if (!bench.error) {
                host.compiled = compiled;
                bench.error = e || new Error(String(e));
              }
            }
          }
        }
        // if no errors run the full test loop
        if (!bench.error) {
          result = compiled.call(deferred || host, timer).elapsed;
        }
        return result;
      };
  
      /*------------------------------------------------------------------------*/
  
      
Gets the current timer's minimum resolution (secs).

  
      function getRes(unit) {
        var measured,
            begin,
            count = 30,
            divisor = 1e3,
            ns = timer.ns,
            sample = [];
  
        // get average smallest measurable time
        while (count--) {
          if (unit == 'us') {
            divisor = 1e6;
            if (ns.stop) {
              ns.start();
              while (!(measured = ns.microseconds())) { }
            } else {
              begin = timer.ns();
              while (!(measured = ns() - begin)) { }
            }
          }
          else if (unit == 'ns') {
            divisor = 1e9;
            begin = ns.nanoTime();
            while (!(measured = ns.nanoTime() - begin)) { }
          }
          else {
            begin = new ns;
            while (!(measured = new ns - begin)) { }
          }
          // check for broken timers (nanoTime may have issues)
          // http://alivebutsleepy.srnet.cz/unreliable-system-nanotime/
          if (measured > 0) {
            sample.push(measured);
          } else {
            sample.push(Infinity);
            break;
          }
        }
        // convert to seconds
        return getMean(sample) / divisor;
      }
  
      
Replaces all occurrences of `` with a unique number and template tokens with content.

  
      function preprocess(code) {
        return interpolate(code, template).replace(/$/g, /\d+/.exec(uid));
      }
  
      /*------------------------------------------------------------------------*/
  
      // detect nanosecond support from a Java applet
      each(window.document && document.applets || [], function(element) {
        return !(timer.ns = applet = 'nanoTime' in element && element);
      });
  
      // check type in case Safari returns an object instead of a number
      try {
        if (typeof timer.ns.nanoTime() == 'number') {
          timers.push({ 'ns': timer.ns, 'res': getRes('ns'), 'unit': 'ns' });
        }
      } catch(e) { }
  
      // detect Chrome's microsecond timer:
      // enable benchmarking via the --enable-benchmarking command
      // line switch in at least Chrome 7 to use chrome.Interval
      try {
        if ((timer.ns = new (window.chrome || window.chromium).Interval)) {
          timers.push({ 'ns': timer.ns, 'res': getRes('us'), 'unit': 'us' });
        }
      } catch(e) { }
  
      // detect Node's microtime module:
      // npm install microtime
      if ((timer.ns = (req('microtime') || { 'now': 0 }).now)) {
        timers.push({ 'ns': timer.ns,  'res': getRes('us'), 'unit': 'us' });
      }
  
      // pick timer with highest resolution
      timer = reduce(timers, function(timer, other) {
        return other.res < timer.res ? other : timer;
      });
  
      // remove unused applet
      if (timer.unit != 'ns' && applet) {
        applet = (applet.parentNode.removeChild(applet), null);
      }
      // error if there are no working timers
      if (timer.res == Infinity) {
        throw new Error('Benchmark.js was unable to find a working timer.');
      }
      // use API of chosen timer
      if (timer.unit == 'ns') {
        extend(template, {
          'begin': 's=n.nanoTime()',
          'end': 'r=(n.nanoTime()-s)/1e9'
        });
      }
      else if (timer.unit == 'us') {
        extend(template, timer.ns.stop ? {
          'begin': 's=n.start()',
          'end': 'r=n.microseconds()/1e6'
        } : {
          'begin': 's=n$()',
          'end': 'r=(n$()-s)/1e6'
        });
      }
  
      // define `timer` methods
      timer.start = createFunction(preprocess('o'),
        preprocess('var n=this.ns,#{begin};o.timeStamp=s'));
  
      timer.stop = createFunction(preprocess('o'),
        preprocess('var n=this.ns,s=o.timeStamp,#{end};o.elapsed=r'));
  
      // resolve time span required to achieve a percent uncertainty of at most 1%
      // http://spiff.rit.edu/classes/phys273/uncert/uncert.html
      options.minTime || (options.minTime = max(timer.res / 2 / 0.01, 0.05));
      return clock.apply(null, arguments);
    }
  
    
Computes stats on benchmark results. @private
parameter: {Object} options The options object.

  
    function compute(options) {
      options || (options = {});
  
      var async = options.async,
          bench = options.benchmark,
          elapsed = 0,
          queue = [],
          sample = [],
          initCount = bench.initCount;
  
      
Adds a number of clones to the queue.

  
      function enqueue(count) {
        while (count--) {
          queue.push(bench.clone({
            '_host': bench,
            'events': { 'start': [update], 'cycle': [update] }
          }));
        }
      }
  
      
Updates the clone/host benchmarks to keep their data in sync.

  
      function update(event) {
        var clone = this,
            cycles = clone.cycles,
            type = event.type;
  
        if (bench.running) {
          if (type == 'cycle') {
            if (clone.error) {
              bench.abort();
              bench.error = clone.error;
              bench.emit('error');
            }
            else {
              // Note: the host's bench.count prop is updated in `clock()`
              bench.hz = clone.hz;
              bench.initCount = clone.initCount;
              bench.times.period = clone.times.period;
              if (cycles > bench.cycles) {
                bench.cycles = cycles;
              }
            }
            bench.emit(type);
          }
          else {
            // reached in clone's onStart
            // Note: clone.minTime prop is inited in `clock()`
            clone.count = bench.initCount;
          }
        } else if (bench.aborted) {
          clone.abort();
        }
      }
  
      
Determines if more clones should be queued or if cycling should stop.

  
      function evaluate(event, clone) {
        var mean,
            moe,
            rme,
            sd,
            sem,
            variance,
            now = +new Date,
            times = bench.times,
            done = bench.aborted,
            maxedOut = (elapsed += now - clone.times.timeStamp) / 1e3 > bench.maxTime,
            size = sample.push(clone.times.period),
            varOf = function(sum, x) { return sum + pow(x - mean, 2); };
  
        // exit early for aborted or unclockable tests
        if (done || clone.hz == Infinity) {
          maxedOut = !(size = sample.length = queue.length = 0);
        }
        // set host values
        if (!done) {
          // sample mean (estimate of the population mean)
          mean = getMean(sample);
          // sample variance (estimate of the population variance)
          variance = reduce(sample, varOf, 0) / (size - 1) || 0;
          // sample standard deviation (estimate of the population standard deviation)
          sd = sqrt(variance);
          // standard error of the mean (a.k.a. the standard deviation of the sampling distribution of the sample mean)
          sem = sd / sqrt(size);
          // margin of error
          moe = sem * getCriticalValue(size - 1);
          // relative margin of error
          rme = (moe / mean) * 100 || 0;
  
          extend(bench.stats, {
            'moe': moe,
            'rme': rme,
            'sem': sem,
            'deviation': sd,
            'mean': mean,
            'size': size,
            'variance': variance
          });
  
          // Exit early when the elapsed time exceeds the maximum time allowed
          // per benchmark. To prevent massive wait times, we do this even if the
          // minimum sample size has not been reached. We don't count cycle delays
          // toward the max time because delays may be increased by browsers that
          // clamp timeouts in inactive tabs.
          // developer.mozilla.org/en/window.setTimeout#Inactive_tabs
          if (maxedOut) {
            done = true;
            bench.running = false;
            bench.initCount = initCount;
            times.elapsed = (now - times.timeStamp) / 1e3;
          }
          if (bench.hz != Infinity) {
            times.period = mean;
            times.cycle = mean * bench.count;
            bench.hz = 1 / mean;
          }
        }
        // if time permits, increase sample size to reduce the margin of error
        if (queue.length < 2 && !maxedOut) {
          enqueue(1);
        }
        // stop the invoke cycle when done
        return !done;
      }
  
      // init queue and begin
      enqueue(bench.minSamples);
      invoke(queue, {
        'name': 'run',
        'args': { 'async': async },
        'queued': true,
        'onCycle': evaluate,
        'onComplete': function() {
          bench.emit('complete');
        }
      });
    }
  
    
Cycles a benchmark until a run `count` can be established. @private
parameter: {Object} options The options object.

  
    function cycle(options) {
      options || (options = {});
  
      var clocked,
          divisor,
          minTime,
          period,
          async = options.async,
          bench = options.benchmark,
          count = bench.count,
          deferred = options.deferred,
          times = bench.times;
  
      // continue, if not aborted between cycles
      if (bench.running) {
        // host `minTime` is set to `Benchmark.options.minTime` in `clock()`
        bench.cycles++;
        clocked = deferred ? deferred.elapsed : clock(bench);
        minTime = bench.minTime;
  
        if (bench.error) {
          bench.abort();
          bench.emit('error');
        }
      }
      // continue, if not errored
      if (bench.running) {
        // time taken to complete last test cycle
        times.cycle = clocked;
        // seconds per operation
        period = times.period = clocked / count;
        // ops per second
        bench.hz = 1 / period;
        // do we need to do another cycle?
        bench.running = clocked < minTime;
        // avoid working our way up to this next time
        bench.initCount = count;
  
        if (bench.running) {
          // tests may clock at `0` when `initCount` is a small number,
          // to avoid that we set its count to something a bit higher
          if (!clocked && (divisor = divisors[bench.cycles]) != null) {
            count = floor(4e6 / divisor);
          }
          // calculate how many more iterations it will take to achive the `minTime`
          if (count <= bench.count) {
            count += Math.ceil((minTime - clocked) / period);
          }
          bench.running = count != Infinity;
        }
      }
      // should we exit early?
      if (bench.emit('cycle') === false) {
        bench.abort();
      }
      // figure out what to do next
      if (bench.running) {
        // start a new cycle
        bench.count = count;
        if (deferred) {
          (bench._host || bench).compiled.call(deferred, timer);
        } else {
          call({
            'async': async,
            'benchmark': bench,
            'fn': function() {
              cycle({ 'async': async, 'benchmark': bench });
            }
          });
        }
      } else {
        // fix TraceMonkey bug associated with clock fallbacks
        // http://bugzil.la/509069
        if (has.browser) {
          runScript(uid + '=1;delete ' + uid);
        }
        // done
        bench.emit('complete');
      }
    }
  
    
Runs the benchmark. @memberOf Benchmark
parameter: {Object} [options={}] Options object.
returns: {Object} The benchmark instance. @example // basic usage bench.run(); // or with options bench.run({ 'async': true });

  
    function run(options) {
      var me = this,
          async = ((async = options && options.async) == null ? me.async : async) && has.timeout;
  
      // set running to false so reset() won't call abort()
      me.running = false;
      me.reset();
      me.running = true;
  
      me.count = me.initCount;
      me.times.timeStamp = +new Date;
      me.emit('start');
  
      if (me._host) {
        if (me.defer) {
          Deferred(me);
        } else {
          cycle({ 'async': async, 'benchmark': me });
        }
      } else {
        compute({ 'async': async, 'benchmark': me });
      }
      return me;
    }
  
    /*--------------------------------------------------------------------------*/
  
    // Firefox 1 erroneously defines variable and argument names of functions on
    // the function itself as non-configurable properties with `undefined` values.
    // The bugginess continues as the `Benchmark` constructor has an argument
    // named `options` and Firefox 1 will not assign a value to `Benchmark.options`,
    // making it non-writable in the process, unless it is the first property
    // assigned by for-in loop of `extend()`.
    extend(Benchmark, {
  
      
The default options copied by benchmark instances. @static @memberOf Benchmark @type Object

  
      'options': {
  
        
A flag to indicate that benchmark cycles will execute asynchronously by default. @memberOf Benchmark.options @type Boolean

  
        'async': false,
  
        
A flag to indicate that the benchmark clock is deferred. @memberOf Benchmark.options @type Boolean

  
        'defer': false,
  
        
The delay between test cycles (secs). @memberOf Benchmark.options @type Number

  
        'delay': 0.005,
  
        
Displayed by Benchmark#toString when a `name` is not available (auto-generated if `null`). @memberOf Benchmark.options @type String|Null

  
        'id': null,
  
        
The default number of times to execute a test on a benchmark's first cycle. @memberOf Benchmark.options @type Number

  
        'initCount': 1,
  
        
The maximum time a benchmark is allowed to run before finishing (secs). Note: Cycle delays aren't counted toward the maximum time. @memberOf Benchmark.options @type Number

  
        'maxTime': 5,
  
        
The minimum sample size required to perform statistical analysis. @memberOf Benchmark.options @type Number

  
        'minSamples': 5,
  
        
The time needed to reduce the percent uncertainty of measurement to 1% (secs). @memberOf Benchmark.options @type Number

  
        'minTime': 0,
  
        
The name of the benchmark. @memberOf Benchmark.options @type String|Null

  
        'name': null
      },
  
      
Platform object with properties describing things like browser name, version, and operating system. @static @memberOf Benchmark @type Object

  
      'platform': req('platform') || window.platform || {
  
        
The platform description. @memberOf Benchmark.platform @type String

  
        'description': window.navigator && navigator.userAgent || null,
  
        
The name of the browser layout engine. @memberOf Benchmark.platform @type String|Null

  
        'layout': null,
  
        
The name of the product hosting the browser. @memberOf Benchmark.platform @type String|Null

  
        'product': null,
  
        
The name of the browser/environment. @memberOf Benchmark.platform @type String|Null

  
        'name': null,
  
        
The name of the product's manufacturer. @memberOf Benchmark.platform @type String|Null

  
        'manufacturer': null,
  
        
The name of the operating system. @memberOf Benchmark.platform @type String|Null

  
        'os': null,
  
        
The alpha/beta release indicator. @memberOf Benchmark.platform @type String|Null

  
        'prerelease': null,
  
        
The browser/environment version. @memberOf Benchmark.platform @type String|Null

  
        'version': null,
  
        
Return platform description when the platform object is coerced to a string. @memberOf Benchmark.platform @type Function
returns: {String} The platform description.

  
        'toString': function() {
          return this.description || '';
        }
      },
  
      
The version number. @static @memberOf Benchmark @type String

  
      'version': '0.3.0',
  
      // clone objects
      'deepClone': deepClone,
  
      // iteration utility
      'each': each,
  
      // augment objects
      'extend': extend,
  
      // generic Array#filter
      'filter': filter,
  
      // generic Array#forEach
      'forEach': forEach,
  
      // generic own property iteration utility
      'forOwn': forOwn,
  
      // converts a number to a comma-separated string
      'formatNumber': formatNumber,
  
      // generic Object#hasOwnProperty
      // (trigger hasKey's lazy define before assigning it to Benchmark)
      'hasKey': (hasKey(Benchmark, ''), hasKey),
  
      // generic Array#indexOf
      'indexOf': indexOf,
  
      // template utility
      'interpolate': interpolate,
  
      // invokes a method on each item in an array
      'invoke': invoke,
  
      // generic Array#join for arrays and objects
      'join': join,
  
      // generic Array#map
      'map': map,
  
      // retrieves a property value from each item in an array
      'pluck': pluck,
  
      // generic Array#reduce
      'reduce': reduce
    });
  
    /*--------------------------------------------------------------------------*/
  
    extend(Benchmark.prototype, {
  
      
The number of times a test was executed. @memberOf Benchmark @type Number

  
      'count': 0,
  
      
The number of cycles performed while benchmarking. @memberOf Benchmark @type Number

  
      'cycles': 0,
  
      
The number of executions per second. @memberOf Benchmark @type Number

  
      'hz': 0,
  
      
The compiled test function. @memberOf Benchmark @type Function|String

  
      'compiled': null,
  
      
The error object if the test failed. @memberOf Benchmark @type Object|Null

  
      'error': null,
  
      
The test to benchmark. @memberOf Benchmark @type Function|String

  
      'fn': null,
  
      
A flag to indicate if the benchmark is aborted. @memberOf Benchmark @type Boolean

  
      'aborted': false,
  
      
A flag to indicate if the benchmark is running. @memberOf Benchmark @type Boolean

  
      'running': false,
  
      
Alias of [`Benchmark#addListener`](#Benchmark:addListener). @memberOf Benchmark, Benchmark.Suite @type Function

  
      'on': addListener,
  
      
Compiled into the test and executed immediately **before** the test loop. @memberOf Benchmark @type Function|String @example // basic usage var bench = Benchmark({ 'setup': function() { var c = this.count, element = document.getElementById('container'); while (c--) { element.appendChild(document.createElement('div')); } }, 'fn': function() { element.removeChild(element.lastChild); } }); // compiles to something like: var c = this.count, element = document.getElementById('container'); while (c--) { element.appendChild(document.createElement('div')); } var start = new Date; while (count--) { element.removeChild(element.lastChild); } var end = new Date - start; // or using strings var bench = Benchmark({ 'setup': '\ var a = 0;\n\ (function() {\n\ (function() {\n\ (function() {', 'fn': 'a += 1;', 'teardown': '\ }())\n\ }())\n\ }())' }); // compiles to something like: var a = 0; (function() { (function() { (function() { var start = new Date; while (count--) { a += 1; } var end = new Date - start; }()) }()) }())

  
      'setup': noop,
  
      
Compiled into the test and executed immediately **after** the test loop. @memberOf Benchmark @type Function|String

  
      'teardown': noop,
  
      
An object of stats including mean, margin or error, and standard deviation. @memberOf Benchmark @type Object

  
      'stats': {
  
        
The margin of error. @memberOf Benchmark#stats @type Number

  
        'moe': 0,
  
        
The relative margin of error (expressed as a percentage of the mean). @memberOf Benchmark#stats @type Number

  
        'rme': 0,
  
        
The standard error of the mean. @memberOf Benchmark#stats @type Number

  
        'sem': 0,
  
        
The sample standard deviation. @memberOf Benchmark#stats @type Number

  
        'deviation': 0,
  
        
The sample arithmetic mean. @memberOf Benchmark#stats @type Number

  
        'mean': 0,
  
        
The sample size. @memberOf Benchmark#stats @type Number

  
        'size': 0,
  
        
The sample variance. @memberOf Benchmark#stats @type Number

  
        'variance': 0
      },
  
      
An object of timing data including cycle, elapsed, period, start, and stop. @memberOf Benchmark @type Object

  
      'times': {
  
        
The time taken to complete the last cycle (secs). @memberOf Benchmark#times @type Number

  
        'cycle': 0,
  
        
The time taken to complete the benchmark (secs). @memberOf Benchmark#times @type Number

  
        'elapsed': 0,
  
        
The time taken to execute the test once (secs). @memberOf Benchmark#times @type Number

  
        'period': 0,
  
        
A timestamp of when the benchmark started (ms). @memberOf Benchmark#times @type Number

  
        'timeStamp': 0
      },
  
      // aborts benchmark (does not record times)
      'abort': abort,
  
      // registers a single listener
      'addListener': addListener,
  
      // creates a new benchmark using the same test and options
      'clone': clone,
  
      // compares benchmark's hertz with another
      'compare': compare,
  
      // executes listeners of a specified type
      'emit': emit,
  
      // removes all listeners of a specified type
      'removeAllListeners': removeAllListeners,
  
      // removes a single listener
      'removeListener': removeListener,
  
      // reset benchmark properties
      'reset': reset,
  
      // runs the benchmark
      'run': run,
  
      // pretty print benchmark info
      'toString': toStringBench
    });
  
    /*--------------------------------------------------------------------------*/
  
    
The default options copied by suite instances. @static @memberOf Benchmark.Suite @type Object

  
    Suite.options = {
  
      
The name of the suite. @memberOf Benchmark.Suite.options @type String|Null

  
      'name': null
    };
  
    /*--------------------------------------------------------------------------*/
  
    extend(Suite.prototype, {
  
      
The number of benchmarks in the suite. @memberOf Benchmark.Suite @type Number

  
      'length': 0,
  
      
A flag to indicate if the suite is aborted. @memberOf Benchmark.Suite @type Boolean

  
      'aborted': false,
  
      
A flag to indicate if the suite is running. @memberOf Benchmark.Suite @type Boolean

  
      'running': false,
  
      
An `Array#forEach` like method. Callbacks may terminate the loop by explicitly returning `false`. @memberOf Benchmark.Suite
parameter: {Function} callback The function called per iteration.
returns: {Object} The suite iterated over.

  
      'forEach': methodize(forEach),
  
      
An `Array#indexOf` like method. @memberOf Benchmark.Suite
parameter: {Mixed} value The value to search for.
returns: {Number} The index of the matched value or `-1`.

  
      'indexOf': methodize(indexOf),
  
      
Invokes a method on all benchmarks in the suite. @memberOf Benchmark.Suite
parameter: {String|Object} name The name of the method to invoke OR options object.
parameter: {Mixed} [arg1, arg2, ...] Arguments to invoke the method with.
returns: {Array} A new array of values returned from each method invoked.

  
      'invoke': methodize(invoke),
  
      
Converts the array to a string. @memberOf Benchmark.Suite
parameter: {String} [separator=','] A string to separate each element of the array.
returns: {String} The removed element.

  
      'join': [].join,
  
      
An `Array#map` like method. @memberOf Benchmark.Suite
parameter: {Function} callback The function called per iteration.
returns: {Array} A new array of values returned by the callback.

  
      'map': methodize(map),
  
      
Retrieves the value of a specified property from all benchmarks in the suite. @memberOf Benchmark.Suite
parameter: {String} property The property to pluck.
returns: {Array} A new array of property values.

  
      'pluck': methodize(pluck),
  
      
Removes the last element of the host array and returns it. @memberOf Benchmark.Suite
returns: {Mixed} The removed element.

  
      'pop': [].pop,
  
      
Appends arguments to the end of the array. @memberOf Benchmark.Suite
returns: {Number} The array length.

  
      'push': [].push,
  
      
Sorts the elements of the host array. @memberOf Benchmark.Suite
parameter: {Function} [compareFn=null] A function that defines the sort order.
returns: {Array} The sorted host array.

  
      'sort': [].sort,
  
      
An `Array#reduce` like method. @memberOf Benchmark.Suite
parameter: {Function} callback The function called per iteration.
parameter: {Mixed} accumulator Initial value of the accumulator.
returns: {Mixed} The accumulator.

  
      'reduce': methodize(reduce),
  
      // aborts all benchmarks in the suite
      'abort': abortSuite,
  
      // adds a benchmark to the suite
      'add': add,
  
      // registers a single listener
      'addListener': addListener,
  
      // creates a new suite with cloned benchmarks
      'clone': cloneSuite,
  
      // executes listeners of a specified type
      'emit': emit,
  
      // creates a new suite of filtered benchmarks
      'filter': filterSuite,
  
      // alias of addListener
      'on': addListener,
  
      // removes all listeners of a specified type
      'removeAllListeners': removeAllListeners,
  
      // removes a single listener
      'removeListener': removeListener,
  
      // resets all benchmarks in the suite
      'reset': resetSuite,
  
      // runs all benchmarks in the suite
      'run': runSuite,
  
      // array methods
      'concat': concat,
  
      'reverse': reverse,
  
      'shift': shift,
  
      'slice': slice,
  
      'splice': splice,
  
      'unshift': unshift
    });
  
    /*--------------------------------------------------------------------------*/
  
    extend(Deferred.prototype, {
  
      
The deferred benchmark instance. @memberOf Benchmark.Deferred @type Object

  
      'benchmark': null,
  
      
The number of deferred cycles performed while benchmarking. @memberOf Benchmark.Deferred @type Number

  
      'cycles': 0,
  
      
The time taken to complete the deferred benchmark (secs). @memberOf Benchmark.Deferred @type Number

  
      'elapsed': 0,
  
      
A timestamp of when the deferred benchmark started (ms). @memberOf Benchmark.Deferred @type Number

  
      'timeStamp': 0,
  
      // cycles/completes the deferred benchmark
      'resolve': resolve
    });
  
    /*--------------------------------------------------------------------------*/
  
    
The event type. @memberOf Benchmark.Event @type String

  
    Event.prototype.type = '';
  
    /*--------------------------------------------------------------------------*/
  
    // expose Deferred, Event and Suite
    extend(Benchmark, {
      'Deferred': Deferred,
      'Event': Event,
      'Suite': Suite
    });
  
    // expose Benchmark
    if (freeExports) {
      // in Node.js or RingoJS v0.8.0+
      if (typeof module == 'object' && module && module.exports == freeExports) {
        (module.exports = Benchmark).Benchmark = Benchmark;
      }
      // in Narwhal or RingoJS v0.7.0-
      else {
        freeExports.Benchmark = Benchmark;
      }
    }
    // via curl.js or RequireJS
    else if (freeDefine) {
      define('benchmark', function() {
        return Benchmark;
      });
    }
    // in a browser or Rhino
    else {
      // use square bracket notation so Closure Compiler won't munge `Benchmark`
      // http://code.google.com/closure/compiler/docs/api-tutorial3.html#export
      window['Benchmark'] = Benchmark;
    }
  
    // trigger clock's lazy define early to avoid a security error
    if (has.air) {
      clock({ 'fn': noop, 'count': 1, 'options': {} });
    }
  }(this));


(C) Æliens 04/09/2009

You may not copy or print any of this material without explicit permission of the author or the publisher. In case of other copyright issues, contact the author.