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

Autogenerated LLM Summary (model llama3.2:3b, generated 28 days 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.

Latest run results:

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

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

Browser/OS: Chrome 130 on Mac OS X 10.15.7

View result in a separate tab

Test name	Executions per second
set f32	12138.3 Ops/sec
set f64	6289.1 Ops/sec
iterate and set f32	10.4 Ops/sec
iterate and set f64	10.4 Ops/sec
iterate and set array	10.4 Ops/sec

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: one year 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 28 days ago):