# Benchmark * [`Benchmark.CALIBRATIONS`](#static-CALIBRATIONS) * [`Benchmark.platform`](#static-platform) * [`Benchmark.version`](#static-version) * [`Benchmark.clearStorage`](#static-clearStorage) * [`Benchmark.each`](#static-each) * [`Benchmark.extend`](#static-extend) * [`Benchmark.filter`](#static-filter) * [`Benchmark.forIn`](#static-forIn) * [`Benchmark.formatNumber`](#static-formatNumber) * [`Benchmark.hasKey`](#static-hasKey) * [`Benchmark.indexOf`](#static-indexOf) * [`Benchmark.interpolate`](#static-interpolate) * [`Benchmark.invoke`](#static-invoke) * [`Benchmark.isArray`](#static-isArray) * [`Benchmark.isCalibrated`](#static-isCalibrated) * [`Benchmark.isClassOf`](#static-isClassOf) * [`Benchmark.isHostType`](#static-isHostType) * [`Benchmark.join`](#static-join) * [`Benchmark.map`](#static-map) * [`Benchmark.noop`](#static-noop) * [`Benchmark.reduce`](#static-reduce) * [`Benchmark.trim`](#static-trim) # Benchmark.prototype * [`Benchmark#CALIBRATION_INDEX`](#CALIBRATION_INDEX) * [`Benchmark#CYCLE_DELAY`](#CYCLE_DELAY) * [`Benchmark#DEFAULT_ASYNC`](#DEFAULT_ASYNC) * [`Benchmark#DETECT_INFINITY`](#DETECT_INFINITY) * [`Benchmark#INIT_RUN_COUNT`](#INIT_RUN_COUNT) * [`Benchmark#MAX_TIME_ELAPSED`](#MAX_TIME_ELAPSED) * [`Benchmark#MIN_TIME`](#MIN_TIME) * [`Benchmark#aborted`](#aborted) * [`Benchmark#count`](#count) * [`Benchmark#created`](#created) * [`Benchmark#cycles`](#cycles) * [`Benchmark#error`](#error) * [`Benchmark#hz`](#hz) * [`Benchmark#persist`](#persist) * [`Benchmark#running`](#running) * [`Benchmark#stats`](#stats) * [`Benchmark#stats.MoE`](#MoE) * [`Benchmark#stats.RME`](#RME) * [`Benchmark#stats.SD`](#SD) * [`Benchmark#stats.SEM`](#SEM) * [`Benchmark#stats.mean`](#mean) * [`Benchmark#stats.size`](#size) * [`Benchmark#stats.variance`](#variance) * [`Benchmark#times`](#times) * [`Benchmark#times.cycle`](#cycle) * [`Benchmark#times.elapsed`](#elapsed) * [`Benchmark#times.period`](#period) * [`Benchmark#times.start`](#start) * [`Benchmark#times.stop`](#stop) * [`Benchmark#abort`](#abort) * [`Benchmark#addListener`](#addListener) * [`Benchmark#clone`](#clone) * [`Benchmark#compare`](#compare) * [`Benchmark#emit`](#emit) * [`Benchmark#on`](#on) * [`Benchmark#removeAllListeners`](#removeAllListeners) * [`Benchmark#removeListener`](#removeListener) * [`Benchmark#reset`](#reset) * [`Benchmark#run`](#run) * [`Benchmark#toString`](#toString) # Benchmark ## Benchmark.CALIBRATIONS *(Array)*: Benchmarks to establish iteration overhead. ^[▲][1] ## Benchmark.platform *(Boolean)*: Platform object containing browser name, version, and operating system. ^[▲][1] ## Benchmark.version *(String)*: The version number. ^[▲][1] ## Benchmark.clearStorage() Removes all benchmark data from local storage. ^[▲][1] ## Benchmark.each(array, callback) A generic bare-bones `Array#forEach` solution. Callbacks may terminate the loop by explicitly returning `false`. ^[▲][1] ### Arguments 1. `array` *(Array)*: The array to iterate over. 2. `callback` *(Function)*: The function called per iteration. ### Returns *(Array)*: The array iterated over. ## Benchmark.extend(destination, source) Copies own/inherited properties of a source object to the destination object. ^[▲][1] ### Arguments 1. `destination` *(Object)*: The destination object. 2. `[source={}]` *(Object)*: The source object. ### Returns *(Object)*: The destination object. ## Benchmark.filter(array, callback) A generic bare-bones `Array#filter` solution. ^[▲][1] ### Arguments 1. `array` *(Array)*: The array to iterate over. 2. `callback` *(Function|String)*: The function/alias called per iteration. ### 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"); ## Benchmark.forIn(object, callback) A generic bare-bones for-in solution for an object's own properties. ^[▲][1] ### Arguments 1. `object` *(Object)*: The object to iterate over. 2. `callback` *(Function)*: The function called per iteration. ### Returns *(Object)*: The object iterated over. ## Benchmark.formatNumber(number) Converts a number to a more readable comma-separated string representation. ^[▲][1] ### Arguments 1. `number` *(Number)*: The number to convert. ### Returns *(String)*: The more readable string representation. ## Benchmark.hasKey(object, key) Checks if an object has the specified key as a direct property. ^[▲][1] ### Arguments 1. `object` *(Object)*: The object to check. 2. `key` *(String)*: The key to check for. ### Returns *(Boolean)*: Returns true if key is a direct property, else false. ## Benchmark.indexOf(array, value) A generic bare-bones `Array#indexOf` solution. ^[▲][1] ### Arguments 1. `array` *(Array)*: The array to iterate over. 2. `value` *(Mixed)*: The value to search for. ### Returns *(Number)*: The index of the matched value or `-1`. ## Benchmark.interpolate(string, object) Modify a string by replacing named tokens with matching object property values. ^[▲][1] ### Arguments 1. `string` *(String)*: The string to modify. 2. `object` *(Object)*: The template object. ### Returns *(String)*: The modified string. ### Example Benchmark.interpolate("#{greet} #{who}!", { "greet": "Hello", "who": "world" }); // -> "Hello world!" ## Benchmark.invoke(benches, name) Invokes a given method, with arguments, on all benchmarks in an array. ^[▲][1] ### Arguments 1. `benches` *(Array)*: Array of benchmarks to iterate over. 2. `name` *(String|Object)*: The name of the method to invoke OR options object. 3. `[, arg1, arg2, ...]` *(Mixed)*: 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 }); ## Benchmark.isArray(value) Determines if the given value is an array. ^[▲][1] ### Arguments 1. `value` *(Mixed)*: The value to check. ### Returns *(Boolean)*: Returns true if value is an array, else false. ## Benchmark.isCalibrated() Checks if calibration benchmarks have completed. ^[▲][1] ### Returns *(Boolean)*: Returns true if calibrated, false if not. ## Benchmark.isClassOf(object, name) Checks if an object is of the specified class. ^[▲][1] ### Arguments 1. `object` *(Object)*: The object. 2. `name` *(String)*: The name of the class. ### Returns *(Boolean)*: Returns true if of the class, else false. ## Benchmark.isHostType(object, property) 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. ^[▲][1] ### Arguments 1. `object` *(Mixed)*: The owner of the property. 2. `property` *(String)*: The property name to check. ### Returns *(Boolean)*: Returns true if the property value is a non-primitive, else false. ## Benchmark.join(object, separator1, separator2) Creates a string of joined array values or object key-value pairs. ^[▲][1] ### Arguments 1. `object` *(Array|Object)*: The object to operate on. 2. `[separator1=',']` *(String)*: The separator used between key-value pairs. 3. `[separator2=': ']` *(String)*: The separator used between keys and values. ### Returns *(String)*: The joined result. ## Benchmark.map(array, callback) A generic bare-bones `Array#map` solution. ^[▲][1] ### Arguments 1. `array` *(Array)*: The array to iterate over. 2. `callback` *(Function)*: The function called per iteration. ### Returns *(Array)*: A new array of values returned by the callback. ## Benchmark.noop() A no-operation function. ^[▲][1] ## Benchmark.reduce(array, callback, accumulator) A generic bare-bones `Array#reduce` solution. ^[▲][1] ### Arguments 1. `array` *(Array)*: The array to iterate over. 2. `callback` *(Function)*: The function called per iteration. 3. `accumulator` *(Mixed)*: Initial value of the accumulator. ### Returns *(Mixed)*: The accumulator. ## Benchmark.trim(string) A generic bare-bones `String#trim` solution. ^[▲][1] ### Arguments 1. `string` *(String)*: The string to trim. ### Returns *(String)*: The trimmed string. # Benchmark.prototype ## Benchmark#CALIBRATION_INDEX *(Number)*: The index of the calibration benchmark to use when computing results. ^[▲][1] ## Benchmark#CYCLE_DELAY *(Number)*: The delay between test cycles *(secs)*. ^[▲][1] ## Benchmark#DEFAULT_ASYNC *(Boolean)*: A flag to indicate methods will run asynchronously by default. ^[▲][1] ## Benchmark#DETECT_INFINITY *(Boolean)*: A flag to indicate protection against large run counts if Infinity ops/sec is detected. ^[▲][1] ## Benchmark#INIT_RUN_COUNT *(Number)*: The default number of times to execute a test on a benchmark's first cycle. ^[▲][1] ## Benchmark#MAX_TIME_ELAPSED *(Number)*: The maximum time a benchmark is allowed to run before finishing *(secs)*. ^[▲][1] ## Benchmark#MIN_TIME *(Number)*: The time needed to reduce the percent uncertainty of measurement to `1`% *(secs)*. ^[▲][1] ## Benchmark#aborted *(Boolean)*: A flag to indicate if the benchmark is aborted. ^[▲][1] ## Benchmark#count *(Number)*: The number of times a test was executed. ^[▲][1] ## Benchmark#created *(Number)*: A timestamp of when the benchmark was created. ^[▲][1] ## Benchmark#cycles *(Number)*: The number of cycles performed while benchmarking. ^[▲][1] ## Benchmark#error *(Object|Null)*: The error object if the test failed. ^[▲][1] ## Benchmark#hz *(Number)*: The number of executions per second. ^[▲][1] ## Benchmark#persist *(Mixed)*: A flag to indicate if results persist OR the number of days to persist. ^[▲][1] ## Benchmark#running *(Boolean)*: A flag to indicate if the benchmark is running. ^[▲][1] ## Benchmark#stats *(Object)*: An object of stats including mean, margin or error, and standard deviation. ^[▲][1] ## Benchmark#stats.MoE *(Number)*: The margin of error. ^[▲][1] ## Benchmark#stats.RME *(Number)*: The relative margin of error *(expressed as a percentage of the mean)*. ^[▲][1] ## Benchmark#stats.SD *(Number)*: The sample standard deviation. ^[▲][1] ## Benchmark#stats.SEM *(Number)*: The standard error of the mean. ^[▲][1] ## Benchmark#stats.mean *(Number)*: The sample arithmetic mean. ^[▲][1] ## Benchmark#stats.size *(Number)*: The sample size. ^[▲][1] ## Benchmark#stats.variance *(Number)*: The sample variance. ^[▲][1] ## Benchmark#times *(Object)*: An object of timing data including cycle, elapsed, period, start, and stop. ^[▲][1] ## Benchmark#times.cycle *(Number)*: The time taken to complete the last cycle *(secs)* ^[▲][1] ## Benchmark#times.elapsed *(Number)*: The time taken to complete the benchmark *(secs)*. ^[▲][1] ## Benchmark#times.period *(Number)*: The time taken to execute the test once *(secs)*. ^[▲][1] ## Benchmark#times.start *(Number)*: A timestamp of when the benchmark started *(ms)*. ^[▲][1] ## Benchmark#times.stop *(Number)*: A timestamp of when the benchmark finished *(ms)*. ^[▲][1] ## Benchmark#abort() Aborts the benchmark as well as in progress calibrations without recording times. ^[▲][1] ### Returns *(Object)*: The benchmark instance. ## Benchmark#addListener(type, listener) Registers a single listener of a specified event type. ^[▲][1] ### Arguments 1. `type` *(String)*: The event type. 2. `listener` *(Function)*: The function called when the event occurs. ### Returns *(Object)*: The benchmark instance. ## Benchmark#clone(options) Creates a cloned benchmark with the same test function and options. ^[▲][1] ### Arguments 1. `options` *(Object)*: Overwrite cloned options. ### Returns *(Object)*: Cloned instance. ### Example var bizarro = bench.clone({ "name": "doppelganger" }); ## Benchmark#compare(other) Determines if the benchmark's hertz is higher than another. ^[▲][1] ### Arguments 1. `other` *(Object)*: The benchmark to compare. ### Returns *(Number)*: Returns `1` if higher, `-1` if lower, and `0` if indeterminate. ## Benchmark#emit(type) Executes all registered listeners of a specified event type. ^[▲][1] ### Arguments 1. `type` *(String)*: The event type. ## Benchmark#on Alias of [`Benchmark#addListener`](#addListener). ^[▲][1] ## Benchmark#removeAllListeners(type) Unregisters all listeners of a specified event type. ^[▲][1] ### Arguments 1. `type` *(String)*: The event type. ### Returns *(Object)*: The benchmark instance. ## Benchmark#removeListener(type, listener) Unregisters a single listener of a specified event type. ^[▲][1] ### Arguments 1. `type` *(String)*: The event type. 2. `listener` *(Function)*: The function to unregister. ### Returns *(Object)*: The benchmark instance. ## Benchmark#reset() Reset properties and abort if running. ^[▲][1] ### Returns *(Object)*: The benchmark instance. ## Benchmark#run(async) Starts running the benchmark. ^[▲][1] ### Arguments 1. `[async=false]` *(Boolean)*: Flag to run asynchronously. ### Returns *(Object)*: The benchmark instance. ## Benchmark#toString() Displays relevant benchmark information when coerced to a string. ^[▲][1] [1]: #readme "Jump back to the TOC."