Benchmark: Array rotate juggling

Script Preparation code:

var arraySmall = new Array(12).map((v,i)=>i);
var arrayMedium = new Array(1200).map((v,i)=>i);
var arrayLong = new Array(120000).map((v,i)=>i);

Tests:

Recursive Small
const rotateArrayRecursive = (numberRotations, array) => { const n = Math.abs(numberRotations); if (n === 0) { return [...array]; } else if (n === 1) { return [array[array.length], ...array.slice(0,array.length-1) ]; } else { return rotateArrayRecursive(1, rotateArrayRecursive(n - 1, array)); } } rotateArrayRecursive(4,arraySmall);
Recursive Medium
const rotateArrayRecursive = (numberRotations, array) => { const n = Math.abs(numberRotations); if (n === 0) { return [...array]; } else if (n === 1) { return [array[array.length], ...array.slice(0,array.length-1) ]; } else { return rotateArrayRecursive(1, rotateArrayRecursive(n - 1, array)); } } rotateArrayRecursive(456,arrayMedium);
Recursive Long
const rotateArrayRecursive = (numberRotations, array) => { const n = Math.abs(numberRotations); if (n === 0) { return [...array]; } else if (n === 1) { return [array[array.length], ...array.slice(0,array.length-1) ]; } else { return rotateArrayRecursive(1, rotateArrayRecursive(n - 1, array)); } } rotateArrayRecursive(45678,arrayLong);
Direct Small
const rotateArrayDirect = (desiredRotation, array) => { // Size of the array, needed later on const arrayLength = array.length; // Ensure we rotate by the right amount, whatever the desiredRotation value // This formula is needed because JS % modulo operator returns negative output for negative inputs const effectiveRotation = ((desiredRotation % arrayLength) + 2 * arrayLength) % arrayLength; // Cut the array in two parts and merge them return [ ...array.slice(effectiveRotation, arrayLength), ...array.slice(0, effectiveRotation) ]; } rotateArrayDirect(4,arraySmall);
Direct Medium
const rotateArrayDirect = (desiredRotation, array) => { // Size of the array, needed later on const arrayLength = array.length; // Ensure we rotate by the right amount, whatever the desiredRotation value // This formula is needed because JS % modulo operator returns negative output for negative inputs const effectiveRotation = ((desiredRotation % arrayLength) + 2 * arrayLength) % arrayLength; // Cut the array in two parts and merge them return [ ...array.slice(effectiveRotation, arrayLength), ...array.slice(0, effectiveRotation) ]; } rotateArrayDirect(456,arrayMedium);
Direct Long
const rotateArrayDirect = (desiredRotation, array) => { // Size of the array, needed later on const arrayLength = array.length; // Ensure we rotate by the right amount, whatever the desiredRotation value // This formula is needed because JS % modulo operator returns negative output for negative inputs const effectiveRotation = ((desiredRotation % arrayLength) + 2 * arrayLength) % arrayLength; // Cut the array in two parts and merge them return [ ...array.slice(effectiveRotation, arrayLength), ...array.slice(0, effectiveRotation) ]; } rotateArrayDirect(45678,arrayLong);
Juggling small
const gcd = (a, b) => { if(b==0){ return a; }else{ return gcd(b, a%b); } } const rotateArrayJuggling = (desiredRotation, array) => { const n = array.length; let temp = null; let j = null; let k = null; const gcdResult = gcd(desiredRotation, n); for (let i = 0; i < gcdResult; i++){ temp = array[i]; j = i; while (true){ k = j + desiredRotation; if (k >= n){ k = k - n; } if (k== i){ break; } array[j] = array[k]; j = k; } array[j] = temp; } return array; } rotateArrayJuggling(4,arraySmall);
Juggling medium
const gcd = (a, b) => { if(b==0){ return a; }else{ return gcd(b, a%b); } } const rotateArrayJuggling = (desiredRotation, array) => { const n = array.length; let temp = null; let j = null; let k = null; const gcdResult = gcd(desiredRotation, n); for (let i = 0; i < gcdResult; i++){ temp = array[i]; j = i; while (true){ k = j + desiredRotation; if (k >= n){ k = k - n; } if (k== i){ break; } array[j] = array[k]; j = k; } array[j] = temp; } return array; } rotateArrayJuggling(456,arrayMedium);
Juggling large
const gcd = (a, b) => { if(b==0){ return a; }else{ return gcd(b, a%b); } } const rotateArrayJuggling = (desiredRotation, array) => { const n = array.length; let temp = null; let j = null; let k = null; const gcdResult = gcd(desiredRotation, n); for (let i = 0; i < gcdResult; i++){ temp = array[i]; j = i; while (true){ k = j + desiredRotation; if (k >= n){ k = k - n; } if (k== i){ break; } array[j] = array[k]; j = k; } array[j] = temp; } return array; } rotateArrayJuggling(45678,arrayLong);

Rendered benchmark preparation results:

Suite status: <idle, ready to run>

Previous results

Test case name	Result
Recursive Small
Recursive Medium
Recursive Long
Direct Small
Direct Medium
Direct Long
Juggling small
Juggling medium
Juggling large

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: 4 years ago)

User agent: Mozilla/5.0 (Macintosh; Intel Mac OS X 10.14; rv:73.0) Gecko/20100101 Firefox/73.0

Browser/OS: Firefox 73 on Mac OS X 10.14

View result in a separate tab

Test name	Executions per second
Recursive Small	168868.3 Ops/sec
Recursive Medium	84.9 Ops/sec
Recursive Long	0.0 Ops/sec
Direct Small	473217.6 Ops/sec
Direct Medium	46451.0 Ops/sec
Direct Long	557.0 Ops/sec
Juggling small	1488881.0 Ops/sec
Juggling medium	339478.8 Ops/sec
Juggling large	1208.2 Ops/sec

Array rotate juggling (version: 0)

Two implementations of array rotatee

Comparing performance of: Recursive Small vs Recursive Medium vs Recursive Long vs Direct Small vs Direct Medium vs Direct Long vs Juggling small vs Juggling medium vs Juggling large

Created: 4 years ago by: Guest

Jump to the latest result

Recursive Small

Recursive Medium

Recursive Long

Direct Small

Direct Medium

Direct Long

Juggling small

Juggling medium

Juggling large

Suite status: <idle, ready to run>

Experimental features:

Fastest: N/A

Slowest: N/A