Benchmark: Mathjs Performance

HTML Preparation code:

<script src="https://cdnjs.cloudflare.com/ajax/libs/mathjs/12.2.0/math.min.js"></script>

Script Preparation code:

var nativearrow = (x, y, z) => x*x + y*y + z*z;
var nativefunc = new Function('x', 'y', 'z', 'return x*x + y*y + z*z')
var mathexpr = math.parse('x^2 + y^2 + z^2')
var mathcomp = mathexpr.compile()
var funcexpr = (x, y, z) => mathexpr.evaluate({x, y, z})
var funccomp = (x, y, z) => mathcomp.evaluate({x, y, z})
var N = 20

Tests:

Native Arrow
const out = [] for (let x = 0; x < N; x += 1) { for (let y = 0; y < N; y += 1) { for (let z = 0; z < N; z += 1) { out.push(nativearrow(x, y, z)) } } }
Native Function
const out = [] for (let x = 0; x < N; x += 1) { for (let y = 0; y < N; y += 1) { for (let z = 0; z < N; z += 1) { out.push(nativefunc(x, y, z)) } } }
Native inline
const out = [] for (let x = 0; x < N; x += 1) { for (let y = 0; y < N; y += 1) { for (let z = 0; z < N; z += 1) { out.push(x*x + y*y + z*z) } } }
Mathjs evaluate
const out = [] for (let x = 0; x < N; x += 1) { for (let y = 0; y < N; y += 1) { for (let z = 0; z < N; z += 1) { out.push(funcexpr(x, y, z)) } } }
Mathjs compile
const out = [] for (let x = 0; x < N; x += 1) { for (let y = 0; y < N; y += 1) { for (let z = 0; z < N; z += 1) { out.push(funccomp(x, y, z)) } } }

Rendered benchmark preparation results:

Suite status: <idle, ready to run>

Previous results

Test case name	Result
Native Arrow
Native Function
Native inline
Mathjs evaluate
Mathjs compile

Fastest: N/A

Slowest: N/A

Autogenerated LLM Summary (model llama3.2:3b, generated 27 days ago):

LLMs can make mistakes. Check important info.

I'll break down the benchmark and explain what's being tested, compared, and their pros and cons.

**Benchmark Definition**

The benchmark defines four different approaches to perform mathematical calculations:

1. **Native inline**: The native JavaScript function `nativearrow` is defined inline within the script.
2. **Native Function**: A new function `nativefunc` is created using the `Function` constructor, which takes three arguments (`x`, `y`, and `z`) and returns the result of `x*x + y*y + z*z`.
3. **Mathjs evaluate**: The Math.js library is used to compile an expression `mathexpr` from a string, which is then evaluated using the `evaluate` method.
4. **Mathjs compile**: Similar to the previous point, but this time the compilation step is performed separately before evaluation.

**Comparison**

Each test case compares the performance of one approach over another. The four tests:

* Compare Native inline and Native Function
* Compare Native inline and Mathjs evaluate
* Compare Native inline and Mathjs compile
* Compare Mathjs evaluate and Mathjs compile

**Options Compared**

Here's a brief overview of each option:

1. **Native inline**: Uses the native JavaScript function `nativearrow` defined within the script.
	* Pros: Can be optimized for performance by the JavaScript engine, uses less memory compared to creating a new function or compiling an expression.
	* Cons: May have lower performance due to the overhead of evaluating a built-in function, and can be less readable if not used correctly.
2. **Native Function**: Creates a new function `nativefunc` using the `Function` constructor.
	* Pros: Allows for more flexibility in defining the function signature and behavior, can be useful for complex calculations or when the native inline approach is not suitable.
	* Cons: Can lead to higher memory usage compared to Native inline, may have lower performance due to the overhead of creating a new function.
3. **Mathjs evaluate**: Compiles an expression `mathexpr` from a string using Math.js and evaluates it using the `evaluate` method.
	* Pros: Allows for more control over the mathematical operation being performed, can be useful for complex calculations or when performance is not critical.
	* Cons: May have higher memory usage compared to Native inline or Native Function, may have lower performance due to the overhead of compiling and evaluating an expression.
4. **Mathjs compile**: Similar to Mathjs evaluate, but this time compilation is performed separately before evaluation.
	* Pros: Can be useful for complex calculations or when performance is not critical, allows for more control over the mathematical operation being performed.
	* Cons: May have higher memory usage compared to Native inline or Native Function, may have lower performance due to the overhead of compiling an expression.

**Performance Comparison**

The benchmark results show that:

* Native inline outperforms Native Function and Mathjs evaluate, likely due to the optimized performance of native JavaScript functions.
* Mathjs compile and Mathjs evaluate perform poorly compared to Native inline and Native Function, likely due to the higher memory usage and potential overhead of compiling and evaluating expressions.

Keep in mind that these results are specific to this benchmark and may not generalize to other use cases or platforms.

Latest run results:

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

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

Browser/OS: Chrome 129 on Mac OS X 10.15.7

View result in a separate tab

Test name	Executions per second
Native Arrow	1401.3 Ops/sec
Native Function	1400.7 Ops/sec
Native inline	2741.5 Ops/sec
Mathjs evaluate	62.4 Ops/sec
Mathjs compile	290.6 Ops/sec

Related benchmarks:

Mathjs Performance (version: 0)

Comparing performance of: Native Arrow vs Native Function vs Native inline vs Mathjs evaluate vs Mathjs compile

Created: 11 months ago by: Guest

Jump to the latest result

Native Arrow

Native Function

Native inline

Mathjs evaluate

Mathjs compile

Suite status: <idle, ready to run>

Experimental features:

Fastest: N/A

Slowest: N/A

Autogenerated LLM Summary (model llama3.2:3b, generated 27 days ago):