Benchmark: math on array vs float32array vs float64array

Script Preparation code:

var a = [...Array(10000)].map(_ => Math.random());
var av2 = [...Array(10000)].map(_ => Math.random());
var ta32 = (new Float32Array(10000)).map(_ => Math.random());
var ta32v2 = (new Float32Array(10000)).map(_ => Math.random());
var ta64 = (new Float64Array(10000)).map(_ => Math.random());
var ta64v2 = (new Float64Array(10000)).map(_ => Math.random());

Tests:

array sort [Async/Deferred]
a.sort();
Float32Array sort [Async/Deferred]
ta32.sort();
Float64Array sort [Async/Deferred]
ta64.sort();
array dot
let sum = 0.0; for (let i = 0; i < 10000; ++i) { sum += a[i] * av2[i]; }
Float32Array dot
let sum = 0.0; for (let i = 0; i < 10000; ++i) { sum += ta32[i] * ta32v2[i]; }
Float64Array dot
let sum = 0.0; for (let i = 0; i < 10000; ++i) { sum += ta64[i] * ta64v2[i]; }

Rendered benchmark preparation results:

Suite status: <idle, ready to run>

Previous results

Test case name	Result
array sort
Float32Array sort
Float64Array sort
array dot
Float32Array dot
Float64Array dot

Fastest: N/A

Slowest: N/A

Latest run results:

Run details: (Test run date: one month ago)

User agent: Mozilla/5.0 (Windows NT 10.0; Win64; x64) AppleWebKit/537.36 (KHTML, like Gecko) Chrome/134.0.0.0 Safari/537.36

Browser/OS: Chrome 134 on Windows

View result in a separate tab

Test name	Executions per second
array sort	1135.2 Ops/sec
Float32Array sort	12454.9 Ops/sec
Float64Array sort	14103.0 Ops/sec
array dot	30443.1 Ops/sec
Float32Array dot	26723.2 Ops/sec
Float64Array dot	29330.3 Ops/sec

Autogenerated LLM Summary (model gpt-4o-mini, generated one month ago):

LLMs can make mistakes. Check important info.

The benchmark defined in the provided JSON compares the performance of various data structures in JavaScript for mathematical operations, specifically focusing on sorting and dot product calculations. The options tested include standard JavaScript arrays, `Float32Array`, and `Float64Array`. Here's a breakdown of the approaches, their pros and cons, and relevant considerations:

### Data Structures Tested

1. **JavaScript Array (`Array`)**
   - **Pros**:
     - Flexible and easy to use.
     - Supports mixed types, meaning you can store integers, strings, and objects in one array.
   - **Cons**:
     - Overhead associated with flexibility; operations can be slower due to this general-purpose nature.
     - Not optimized for memory usage when dealing with numerical data.

2. **Float32Array**
   - **Pros**:
     - Stores 32-bit floating-point numbers.
     - More memory-efficient for numerical data compared to regular arrays, as it uses less memory per element.
     - Beneficial for performance in scenarios where large datasets need to be processed (e.g., graphics processing, scientific calculations).
   - **Cons**:
     - Limited to 32-bit precision; may cause rounding errors for very large or very small numbers.
     - Only stores numerical values, so it cannot hold other data types.
   
3. **Float64Array**
   - **Pros**:
     - Stores 64-bit floating-point numbers, providing better precision for numerical calculations compared to `Float32Array`.
     - Also memory-efficient for numerical data and suitable for high-precision applications.
   - **Cons**:
     - Uses more memory per element than `Float32Array`, which may be a drawback in large datasets with less precision needed.

### Benchmark Cases

1. **Sorting**
   - **JavaScript Array Sort**: Tests the built-in sort method for standard arrays.
   - **Float32Array Sort**: Similarly tests sorting but on `Float32Array`.
   - **Float64Array Sort**: Conducting the same sorting test but on `Float64Array`.
   - **Performance Results**: The results show that sorting on regular arrays is significantly slower compared to the typed arrays (`Float32Array` and `Float64Array`).

2. **Dot Product Calculation**
   - **Array Dot**: Computes the dot product of two regular arrays.
   - **Float32Array Dot**: Computes the dot product using `Float32Array`.
   - **Float64Array Dot**: Computes the dot product using `Float64Array`.
   - **Performance Results**: The benchmarks reveal that the floating-point arrays outperform regular arrays when performing dot product operations.

### Special Considerations

- **Memory Allocation**: `Float32Array` and `Float64Array` are types of "typed arrays" in JavaScript. Typed arrays provide a mechanism for reading and writing to binary data buffers, offering better performance for specific use cases involving numbers, especially in graphics and scientific calculations.

- **Precision Requirements**: When choosing between `Float32Array` and `Float64Array`, developers must balance between memory usage and the precision required by the application. For high-precision calculations, `Float64Array` is preferable, but for graphics and scenarios where precision is less critical, `Float32Array` is often adequate and more memory efficient.

### Other Alternatives

- **Other Typed Arrays**: Besides `Float32Array` and `Float64Array`, JavaScript also provides `Int8Array`, `Uint8Array`, and several others. Each serves different purposes depending on whether you need signed or unsigned integers and the specific range of values.

- **Libraries**: There are numerous libraries that can aid in numerical computations, such as:
   - **Math.js**: A comprehensive library for mathematical functions and matrices.
   - **NumPy (via Pyodide)**: Offers numerical computations in Python for more complex operations, enabling JavaScript to leverage Python’s powerful libraries.

- **WebAssembly**: For maximum performance, especially in computational-heavy applications, converting performance-critical code to WebAssembly (Wasm) can provide huge speed-ups over JavaScript.

This benchmark highlights how distinct data structures in JavaScript can have significant implications for performance, especially in numerical applications. The choice amongst them should revolve around the specific requirements of the application, considering both precision and memory efficiency.

Related benchmarks:

math on array vs float32array vs float64array (version: 4)

Comparing performance of: array sort vs Float32Array sort vs Float64Array sort vs array dot vs Float32Array dot vs Float64Array dot

Created: one month ago by: Registered User

Jump to the latest result

array sort [Async/Deferred]

Float32Array sort [Async/Deferred]

Float64Array sort [Async/Deferred]

array dot

Float32Array dot

Float64Array dot

Suite status: <idle, ready to run>

Experimental features:

Fastest: N/A

Slowest: N/A

Autogenerated LLM Summary (model gpt-4o-mini, generated one month ago):