Benchmark: Sorting speed comparison

Script Preparation code:

var sortDirections = {
  DEFAULT: -1,
  ASC: 1,
  DESC: -1,
};

var numberArrayToSort = [1, 4, 3, 2, 5, 6, 9, 10, 5, 8, 7, 1, 4, 3, 2, 5, 6, 9, 10, 5, 8, 7, 1, 4, 3, 2, 5, 6, 9, 10, 5, 8, 7, 1, 4, 3, 2, 5, 6, 9, 10, 5, 8, 7, 1, 4, 3, 2, 5, 6, 9, 10, 5, 8, 7, 1, 4, 3, 2, 5, 6, 9, 10, 5, 8, 7, 1, 4, 3, 2, 5, 6, 9, 10, 5, 8, 7, 1, 4, 3, 2, 5, 6, 9, 10, 5, 8, 7, 1, 4, 3, 2, 5, 6, 9, 10, 5, 8, 7];

// ---------------------------------

var compare = (lessThan, equalTo) => {
  if (equalTo) {
    return 0;
  }

  if (lessThan) {
    return -1;
  }

  return 1;
};

var compareStraight = (a, b) => {
  if (a === b) {
    return 0;
  }

  if (a < b) {
    return -1;
  }

  return 1;
};


var compareStraightNumber = (a, b) => a - b;

// ---------------------------------

var primitiveTypeComparator = (a, b) => compare(a < b, a === b);

var genericDirectionComparator = (comparator = primitiveTypeComparator) => (a, b, direction = sortDirections.ASC) => {
  return direction * comparator(a, b);
};

var sortByNumberComparator = genericDirectionComparator();

// ---------------------------------

var sortDirectionWrapper = (compareFunc, direction = sortDirections.ASC) => (a, b) => compareFunc(a, b) * direction;
var cleanStraightSort = (direction) => sortDirectionWrapper(compareStraight, direction);
var cleanStraightSortFast = (direction) => sortDirectionWrapper(compareStraightNumber, direction);

// ---------------------------------

​x
 
var sortDirections = {  DEFAULT: -1,  ASC: 1,  DESC: -1,};​var numberArrayToSort = [1, 4, 3, 2, 5, 6, 9, 10, 5, 8, 7, 1, 4, 3, 2, 5, 6, 9, 10, 5, 8, 7, 1, 4, 3, 2, 5, 6, 9, 10, 5, 8, 7, 1, 4, 3, 2, 5, 6, 9, 10, 5, 8, 7, 1, 4, 3, 2, 5, 6, 9, 10, 5, 8, 7, 1, 4, 3, 2, 5, 6, 9, 10, 5, 8, 7, 1, 4, 3, 2, 5, 6, 9, 10, 5, 8, 7, 1, 4, 3, 2, 5, 6, 9, 10, 5, 8, 7, 1, 4, 3, 2, 5, 6, 9, 10, 5, 8, 7];​// ---------------------------------​var compare = (lessThan, equalTo) => {  if (equalTo) {    return 0;  }​  if (lessThan) {    return -1;  }​  return 1;};​var compareStraight = (a, b) => {  if (a === b) {    return 0;  }​  if (a < b) {    return -1;  }​  return 1;};​​var compareStraightNumber = (a, b) => a - b;​// ---------------------------------​var primitiveTypeComparator = (a, b) => compare(a < b, a === b);​var genericDirectionComparator = (comparator = primitiveTypeComparator) => (a, b, direction = sortDirections.ASC) => {  return direction * comparator(a, b);};​var sortByNumberComparator = genericDirectionComparator();​// ---------------------------------​var sortDirectionWrapper = (compareFunc, direction = sortDirections.ASC) => (a, b) => compareFunc(a, b) * direction;var cleanStraightSort = (direction) => sortDirectionWrapper(compareStraight, direction);var cleanStraightSortFast = (direction) => sortDirectionWrapper(compareStraightNumber, direction);​// ---------------------------------

Tests:

PR Code
numberArrayToSort.sort((a, b) => sortByNumberComparator(a, b, sortDirections.ASC));
numberArrayToSort.sort((a, b) => sortByNumberComparator(a, b, sortDirections.ASC));
Comparison Code
numberArrayToSort.sort(sortDirectionWrapper(primitiveTypeComparator, sortDirections.ASC));
numberArrayToSort.sort(sortDirectionWrapper(primitiveTypeComparator, sortDirections.ASC));
Comparison Code 2, simple sort function
numberArrayToSort.sort(sortDirectionWrapper(compareStraight, sortDirections.ASC));
numberArrayToSort.sort(sortDirectionWrapper(compareStraight, sortDirections.ASC));
Comparison Code 3, syntactic sugar
numberArrayToSort.sort(cleanStraightSort(sortDirections.ASC))
numberArrayToSort.sort(cleanStraightSort(sortDirections.ASC))
Comparison Code 4, now even quicker?
numberArrayToSort.sort(cleanStraightSortFast(sortDirections.ASC))
numberArrayToSort.sort(cleanStraightSortFast(sortDirections.ASC))

Rendered benchmark preparation results:

Suite status: <idle, ready to run>

Previous results

Experimental features:

Memory measurements supported only in Chrome.
For precise memory measurements Chrome must be launched with --enable-precise-memory-info flag.
More information: Monitoring JavaScript Memory

Test case name	Result
PR Code
Comparison Code
Comparison Code 2, simple sort function
Comparison Code 3, syntactic sugar
Comparison Code 4, now even quicker?

Fastest: N/A

Slowest: N/A

Latest run results:

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

User agent: Mozilla/5.0 (Macintosh; Intel Mac OS X 10_13_1) AppleWebKit/537.36 (KHTML, like Gecko) Chrome/63.0.3239.132 Safari/537.36

Browser/OS: Chrome 63 on Mac OS X 10.13.1

View result in a separate tab

Test name	Executions per second
PR Code	33918.4 Ops/sec
Comparison Code	90685.2 Ops/sec

Autogenerated LLM Summary (model llama3.2:3b, generated 6 months ago):

I'll break down the provided benchmark and explain what's being tested.

Benchmark Overview

The benchmark compares different approaches to sorting an array of numbers in JavaScript. The sorting algorithm used is not explicitly specified, but it's assumed to be a stable sort like Merge Sort or Insertion Sort, which maintains the relative order of equal elements.

Tested Options

There are four test cases:

PR Code: Uses the sortByNumberComparator function, which is a curried version of the comparison function.
Comparison Code: Directly calls the compare function with the sorting direction set to ascending (sortDirections.ASC).
Comparison Code 2 (simple sort): Similar to Comparison Code, but uses a simpler sorting function (compareStraight) instead of currying.
Comparison Code 3 (syntactic sugar): Uses a syntactic sugar version of the comparison function (cleanStraightSort), which is similar to sortByNumberComparator.
Comparison Code 4 (now even quicker?): A variant of Comparison Code 3, optimized for performance by removing unnecessary checks.

Pros and Cons

Currying (PR Code vs Comparison Code): Currying can improve code readability and make it easier to compose functions, but it may also incur a small performance overhead due to the additional function call.
Simplification (Comparison Code 2 vs Comparison Code): Using a simpler sorting function like compareStraight can reduce overhead, but may not be as efficient as the curried version or other approaches.
Syntactic sugar (Comparison Code 3 and 4): Syntactic sugar can make code easier to read and write, but may also add some overhead due to the compiler or interpreter.

Library/Function Explanation

The compare function is a simple comparison function that returns -1 if the first element is less than the second, 0 if they are equal, and 1 if the first element is greater. The sortByNumberComparator function is a curried version of this comparison function, which allows it to be composed with other functions.

Special JS Feature/Syntax

The benchmark uses some advanced JavaScript features, including:

Currying (function composition)
Syntactic sugar (using cleanStraightSort instead of the full sortDirectionWrapper function)

However, these features are not specific to JavaScript and can be found in other programming languages as well.

Other Alternatives

Other sorting algorithms that could be tested in this benchmark include:

Quick Sort
Heap Sort
Radix Sort (for large datasets)
Timsort (a hybrid of Merge Sort and Insertion Sort)

Additionally, the benchmark could also explore different sorting techniques, such as:

Bubble Sort
Selection Sort
Insertion Sort

or even non-comparative sorting algorithms like:

Counting Sort
Bucket Sort

LLMs can make mistakes. Check important info.

I'll break down the provided benchmark and explain what's being tested.

**Benchmark Overview**

**Tested Options**

There are four test cases:

1. **PR Code**: Uses the `sortByNumberComparator` function, which is a curried version of the comparison function.
2. **Comparison Code**: Directly calls the `compare` function with the sorting direction set to ascending (`sortDirections.ASC`).
3. **Comparison Code 2 (simple sort)**: Similar to Comparison Code, but uses a simpler sorting function (`compareStraight`) instead of currying.
4. **Comparison Code 3 (syntactic sugar)**: Uses a syntactic sugar version of the comparison function (`cleanStraightSort`), which is similar to `sortByNumberComparator`.
5. **Comparison Code 4 (now even quicker?)**: A variant of Comparison Code 3, optimized for performance by removing unnecessary checks.

**Pros and Cons**

* **Currying (PR Code vs Comparison Code)**: Currying can improve code readability and make it easier to compose functions, but it may also incur a small performance overhead due to the additional function call.
* **Simplification (Comparison Code 2 vs Comparison Code)**: Using a simpler sorting function like `compareStraight` can reduce overhead, but may not be as efficient as the curried version or other approaches.
* **Syntactic sugar (Comparison Code 3 and 4)**: Syntactic sugar can make code easier to read and write, but may also add some overhead due to the compiler or interpreter.

**Library/Function Explanation**

The `compare` function is a simple comparison function that returns -1 if the first element is less than the second, 0 if they are equal, and 1 if the first element is greater. The `sortByNumberComparator` function is a curried version of this comparison function, which allows it to be composed with other functions.

**Special JS Feature/Syntax**

The benchmark uses some advanced JavaScript features, including:

* Currying (function composition)
* Syntactic sugar (using `cleanStraightSort` instead of the full `sortDirectionWrapper` function)

However, these features are not specific to JavaScript and can be found in other programming languages as well.

**Other Alternatives**

Other sorting algorithms that could be tested in this benchmark include:

* Quick Sort
* Heap Sort
* Radix Sort (for large datasets)
* Timsort (a hybrid of Merge Sort and Insertion Sort)

Additionally, the benchmark could also explore different sorting techniques, such as:

* Bubble Sort
* Selection Sort
* Insertion Sort

or even non-comparative sorting algorithms like:

* Counting Sort
* Bucket Sort

Related benchmarks:

Sorting speed comparison (version: 10)

Test of sorting speed and approach to currying

Comparing performance of: PR Code vs Comparison Code vs Comparison Code 2, simple sort function vs Comparison Code 3, syntactic sugar vs Comparison Code 4, now even quicker?

Created: 7 years ago by: Registered User

Jump to the latest result

PR Code

Comparison Code

Comparison Code 2, simple sort function

Comparison Code 3, syntactic sugar

Comparison Code 4, now even quicker?

Suite status: <idle, ready to run>

Experimental features:

Fastest: N/A

Slowest: N/A

Autogenerated LLM Summary (model llama3.2:3b, generated 6 months ago):