Benchmark: Float32 vs Float64 vs Array

Script Preparation code:

var length = 1e6;

var f32_a = Float32Array.from({length}, Math.random);
var f32_b = Float32Array.from({length}, Math.random);

var f64_a = Float64Array.from({length}, Math.random);
var f64_b = Float64Array.from({length}, Math.random);

var arr_a = Array.from({length}, Math.random);
var arr_b = Array.from({length}, Math.random);

Tests:

set f32
f32_a.set(f32_b);
set f64
f64_a.set(f64_b);
iterate and set f32
for (let i = 0; i < length; i++) { f32_a[i] = f32_b[i]; }
iterate and set f64
for (let i = 0; i < length; i++) { f64_a[i] = f64_b[i]; }
iterate and set array
for (let i = 0; i < length; i++) { arr_a[i] = arr_b[i]; }

Rendered benchmark preparation results:

Suite status: <idle, ready to run>

Previous results

Test case name	Result
set f32
set f64
iterate and set f32
iterate and set f64
iterate and set array

Fastest: N/A

Slowest: N/A

Latest run results:

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

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

Browser/OS: Chrome 135 on Windows

View result in a separate tab

Test name	Executions per second
set f32	6732.0 Ops/sec
set f64	2852.9 Ops/sec
iterate and set f32	256.1 Ops/sec
iterate and set f64	245.7 Ops/sec
iterate and set array	273.3 Ops/sec

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

LLMs can make mistakes. Check important info.

**What is being tested?**

MeasureThat.net is testing the performance of different data types (Float32, Float64, and Array) in JavaScript for common operations:

1. Setting values using `set()`
2. Iterating over elements and setting values
3. Creating a new array by iterating over existing arrays

**Options compared**

The benchmark compares three options:

1. **Array**: An indexed array of primitive numbers (Float32 or Float64)
2. **Float32Array**: A typed array optimized for 32-bit floating-point numbers
3. **Float64Array**: A typed array optimized for 64-bit floating-point numbers

**Pros and Cons**

Here's a brief overview of the pros and cons of each option:

1. **Array**:
	* Pros: Simple, widely supported, and familiar to developers.
	* Cons: Less efficient than typed arrays due to the overhead of boxing/unboxing primitive values.
2. **Float32Array**:
	* Pros: Optimized for 32-bit floating-point numbers, can lead to better performance in some cases.
	* Cons: Requires explicit type declaration, may not be supported by all browsers or environments.
3. **Float64Array**:
	* Pros: Optimized for 64-bit floating-point numbers, provides a good balance between simplicity and performance.
	* Cons: Still requires explicit type declaration, may have slightly higher overhead compared to Float32Array.

**Libraries and special JS features**

None of the test cases use libraries or special JavaScript features that would impact their behavior. The focus is solely on comparing the performance of different data types.

**Other alternatives**

If you wanted to add more options to the benchmark, you could consider:

* **BigInt**: A new type in ECMAScript 2020 for representing integers with arbitrary precision.
* **Int32Array** and **Int64Array**: Typed arrays optimized for 32-bit and 64-bit integers, respectively.
* **Buffer**: An array-like object that provides a more efficient way to store binary data.

Keep in mind that adding new options would require updating the benchmark script and ensuring compatibility with various browsers and environments.

Related benchmarks:

Float32 vs Float64 vs Array (version: 0)

Comparing performance of: set f32 vs set f64 vs iterate and set f32 vs iterate and set f64 vs iterate and set array

Created: 2 years ago by: Guest

Jump to the latest result

set f32

set f64

iterate and set f32

iterate and set f64

iterate and set array

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):