Benchmark: static class vs functions

Tests:

class
class Trig { static cos(z) { return Math.cos(z); } static sin(z) { return Math.sin(z); } static tan(z) { return Math.tan(z); } static cosh(z) { return Math.cosh(z); } static sinh(z) { return Math.sinh(z); } static tanh(z) { return Math.tanh(z); } static acos(z) { return Math.acos(z); } static asin(z) { return Math.asin(z); } static atan(z) { return Math.atan(z); } static acosh(z) { return Math.acosh(z); } static asinh(z) { return Math.asinh(z); } static atanh(z) { return Math.atanh(z); } }
functions
function cos(z) { return Math.cos(z); } function sin(z) { return Math.sin(z); } function tan(z) { return Math.tan(z); } function cosh(z) { return Math.cosh(z); } function sinh(z) { return Math.sinh(z); } function tanh(z) { return Math.tanh(z); } function acos(z) { return Math.acos(z); } function asin(z) { return Math.asin(z); } function atan(z) { return Math.atan(z); } function acosh(z) { return Math.acosh(z); } function asinh(z) { return Math.asinh(z); } function atanh(z) { return Math.atanh(z); }

Rendered benchmark preparation results:

Suite status: <idle, ready to run>

Previous results

Test case name	Result
class
functions

Fastest: N/A

Slowest: N/A

Latest run results:

Run details: (Test run date: 6 months ago)

User agent: Mozilla/5.0 (Windows NT 10.0; Win64; x64; rv:128.0) Gecko/20100101 Goanna/6.8 Firefox/128.0 PaleMoon/33.9.1

Browser/OS: Pale Moon (Firefox Variant) 33 on Windows

View result in a separate tab

Test name	Executions per second
class	61636.6 Ops/sec
functions	2139480960.0 Ops/sec

Autogenerated LLM Summary (model llama3.2:3b, generated one year ago):

LLMs can make mistakes. Check important info.

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

The benchmark compares two approaches to implement mathematical functions in JavaScript: static classes vs functions.

**Static Classes**

In this approach, we define a class `Trig` with static methods for each mathematical function (e.g., `cos(z)`, `sin(z)`, etc.). These methods simply call the corresponding built-in `Math` method to perform the calculation.

**Functions**

In this approach, we define separate named functions for each mathematical function (e.g., `function cos(z) { ... }`). These functions also call the corresponding built-in `Math` method to perform the calculation.

**What's being tested?**

The benchmark measures the performance difference between these two approaches. Specifically, it tests:

* The execution speed of each approach in terms of **executions per second** on a given browser (Firefox 91) and device platform (Desktop Windows).

**Pros and Cons:**

**Static Classes:**

Pros:

* Can be more concise and easier to read, as the functions are defined within the class.
* May be faster due to reduced function call overhead.

Cons:

* Can lead to tighter coupling between functions, making it harder to maintain or refactor the code.
* May require additional boilerplate code for error handling or parameter validation.

**Functions:**

Pros:

* More flexible and modular, as each function can be easily reused or replaced independently.
* Easier to test and debug individual components.

Cons:

* Can lead to more verbose code and increased overhead due to function call overhead.
* May require additional setup or configuration for error handling or parameter validation.

**Other Considerations:**

* The benchmark results are based on Firefox 91 and Desktop Windows. Future benchmarks should consider other browsers, platforms, and JavaScript engines to ensure consistent and representative comparisons.
* The `executionsPerSecond` metric measures performance in terms of raw speed. However, this may not accurately reflect real-world use cases or applications where code readability, maintainability, and scalability are more important.

**Libraries and Special JS Features:**

There are no libraries used in this benchmark. However, the use of named functions (`function cos(z) { ... }`) is a common JavaScript feature that can be used to define reusable functions.

**Alternatives:**

Other approaches to implement mathematical functions in JavaScript include:

* **Closures**: Using closures to create private, encapsulated functions for each mathematical operation.
* **Method chaining**: Combining multiple method calls to reduce function call overhead and improve readability.
* **Object creation**: Creating objects with methods that perform the mathematical operations, similar to the static class approach.

These alternatives can offer trade-offs between performance, conciseness, flexibility, and maintainability, depending on the specific use case and requirements.

Related benchmarks:

static class vs functions (version: 0)

Comparing performance of: class vs functions

Created: 5 years ago by: Guest

Jump to the latest result

class

functions

Suite status: <idle, ready to run>

Fastest: N/A

Slowest: N/A

Autogenerated LLM Summary (model llama3.2:3b, generated one year ago):