Benchmark: Generate Ticks - MeasureThat.net

Script Preparation code:

const e10 = Math.sqrt(50);
const e5 = Math.sqrt(10);
const e2 = Math.sqrt(2);

function generateTicks(start, stop, count) {
  let reverse;
  let i = -1;
  let n;
  let ticks;
  let step;
  stop = +stop;
  start = +start;
  count = +count;
  if (start === stop && count > 0) {
    return [start];
  }
  if ((reverse = stop < start)) {
    n = start;
    start = stop;
    stop = n;
  }
  if ((step = tickIncrement(start, stop, count)) === 0 || !isFinite(step)) {
    return [];
  }

  if (step > 0) {
    start = Math.ceil(start / step);
    stop = Math.floor(stop / step);
    ticks = new Array((n = Math.ceil(stop - start + 1)));
    while (++i < n) ticks[i] = (start + i) * step;
  } else {
    start = Math.floor(start * step);
    stop = Math.ceil(stop * step);
    ticks = new Array((n = Math.ceil(start - stop + 1)));
    while (++i < n) ticks[i] = (start - i) / step;
  }
  if (reverse) ticks.reverse();
  return ticks;
}


function tickIncrement(
  start,
  stop,
  count,
) {
  const step = (stop - start) / Math.max(0, count);
  const power = Math.floor(Math.log(step) / Math.LN10);
  const error = step / Math.pow(10, power);
  return power >= 0
    ? (error >= e10 ? 10 : error >= e5 ? 5 : error >= e2 ? 2 : 1) *
        Math.pow(10, power)
    : -Math.pow(10, -power) /
        (error >= e10 ? 10 : error >= e5 ? 5 : error >= e2 ? 2 : 1);
}

function niceNumber(range, round) {
  const exponent = Math.floor(Math.log10(range));
  const fraction = range / Math.pow(10, exponent);
  let niceFraction;

  if (round) {
    if (fraction < 1.5) {
      niceFraction = 1;
    } else if (fraction < 3) {
      niceFraction = 2;
    } else if (fraction < 7) {
      niceFraction = 5;
    } else {
      niceFraction = 10;
    }
  } else {
    if (fraction <= 1.0) {
      niceFraction = 1;
    } else if (fraction <= 2) {
      niceFraction = 2;
    } else if (fraction <= 5) {
      niceFraction = 5;
    } else {
      niceFraction = 10;
    }
  }

  return niceFraction * Math.pow(10, exponent);
}
domain = [1000, 200];
function ticks1(count) {
  const niceRange = niceNumber(domain[1] - domain[0], false);
  const spacing = niceNumber(niceRange / (count - 1), true);
  const niceMin = Math.floor(domain[0] / spacing) * spacing;
  const niceMax = Math.ceil(domain[1] / spacing) * spacing;

  // Put the values into the ticks array
  const ticks = [];
  for (let j = niceMin; j <= niceMax; j += spacing) {
    ticks.push(j);
  }
  return ticks;
}

function ticks2(count) {
	generateTicks(domain[0], domain[1], count)
}

Tests:

ticks1
ticks1(12);
ticks2
ticks2(12);

Rendered benchmark preparation results:

Suite status: <idle, ready to run>

Previous results

Test case name	Result
ticks1
ticks2

Fastest: N/A

Slowest: N/A

ⓘ Get performance results from real users on your website with Request Metrics.

Website Performance Monitoring by Request Metrics

Latest run results:

Run details: (Test run date: 5 years ago)

User agent: Mozilla/5.0 (Windows NT 6.3) AppleWebKit/537.36 (KHTML, like Gecko) Chrome/70.0.3538.110 Safari/537.36

Browser/OS: Chrome 70 on Windows 8.1

View result in a separate tab

Test name	Executions per second
ticks1	100907.5 Ops/sec
ticks2	85506.1 Ops/sec

Generate Ticks (version: 0)

Generate Ticks

Comparing performance of: ticks1 vs ticks2

Created: 5 years ago by: Guest

Jump to the latest result

ticks1

ticks2

Suite status: <idle, ready to run>

Experimental features:

Fastest: N/A

Slowest: N/A