Benchmark: Math.abs speed vs multiply full example vs steps

Script Preparation code:

var value = -0.07
var step = 0.01
var min = -5
// sorry we must use var and not let and const
function validateStepWithAbs(value, step, min = 0) {
    if (value == null) return false

    var absValue = Math.abs(value)
    var absStep = Math.abs(step)
    var absMin = Math.abs(min)

    while (
        (absValue > 0 && absValue < 1) ||
        (absStep > 0 && absStep < 1) ||
        (absMin > 0 && absMin < 1)
    ) {
        value *= 10
        step *= 10
        min *= 10

        absValue = Math.abs(value)
        absStep = Math.abs(step)
        absMin = Math.abs(min)
    }

    return (value - min) % step === 0
}

function validateStepWithMultiply(value, step, min = 0) {
    if (value == null) return false

    while (
        (value !== 0 && value * value < 1) ||
        (step !== 0 && step * step < 1) ||
        (min !== 0 && min * min < 1)
    ) {
        value *= 10
        step *= 10
        min *= 10
    }

    return (value - min) % step === 0
}

function validateStepWithSteps(value, step, min = 0) {
    if (value == null) return false
    var steps = (value - min) / step
    var remainder = steps % 1
    // Since the remainder could be close to either 0.99999999999999 or 0.00000000000001
    remainder = Math.round((remainder) * 1000000000) / 1000000000
    return remainder === 0 || remainder === 1
}

Tests:

Math.abs(x)
validateStepWithAbs(value, step, min)
compare x*x
validateStepWithMultiply(value, step, min)
use steps
validateStepWithSteps(value, step, min)

Rendered benchmark preparation results:

Suite status: <idle, ready to run>

Previous results

Test case name	Result
Math.abs(x)
compare x*x
use steps

Fastest: N/A

Slowest: N/A

Latest run results:

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

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

Browser/OS: Chrome 131 on Windows

View result in a separate tab

Test name	Executions per second
Math.abs(x)	27924744.0 Ops/sec
compare x*x	32819730.0 Ops/sec
use steps	29904274.0 Ops/sec

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

LLMs can make mistakes. Check important info.

I'd be happy to help explain what's being tested in this JavaScript benchmark.

**Overview**

The benchmark measures the performance of three different approaches for validating whether `(value - min) % step === 0`:

1. `Math.abs`
2. Multiplication (`x * x`)
3. Using steps (`(value - min) / step`)

These approaches are used to test a specific scenario where a value `x` is repeatedly incremented by a factor of 10 until it meets the condition.

**Options compared**

The three options being compared are:

1. **Math.abs**: uses the built-in `Math.abs` function to calculate the absolute value of `value`.
2. **Multiplication (`x * x`)**: multiplies `value` by itself repeatedly until it meets the condition.
3. **Using steps (`(value - min) / step`)**: calculates the number of steps needed to reach `min` from `value` and checks if the remainder is 0.

**Pros and Cons**

Here's a brief summary of each approach:

1. **Math.abs**:
	* Pros: simple, efficient, and widely supported.
	* Cons: may not be as accurate for very large values due to floating-point precision issues.
2. **Multiplication (`x * x`)**:
	* Pros: can be more accurate than `Math.abs` for very large values, but is less efficient and may overflow for large values.
	* Cons: can be slower and less scalable than other approaches.
3. **Using steps (`(value - min) / step`)**:
	* Pros: highly scalable and can handle very large values without overflowing.
	* Cons: requires more calculations and may be slower due to the division operation.

**Library and special JS features**

In this benchmark, there are no specific libraries or special JavaScript features being used. The code is relatively simple and only relies on built-in JavaScript functions and operators.

**Alternative approaches**

Other approaches that could potentially be used for validating `(value - min) % step === 0` include:

1. **Bitwise operations**: using bitwise shift and comparison operations to calculate the remainder.
2. **Modular arithmetic**: using modular arithmetic properties to simplify the calculation.
3. **Arithmetic-geometric means (AGM)**: using an iterative method to compute the AGM of `value` and `min`.

These alternative approaches may offer better performance or accuracy for specific use cases, but are not shown in this benchmark.

I hope this helps explain what's being tested in this JavaScript benchmark!

Related benchmarks:

Math.abs speed vs multiply full example vs steps (version: 0)

Comparing performance of: Math.abs(x) vs compare x*x vs use steps

Created: one year ago by: Guest

Jump to the latest result

Math.abs(x)

compare x*x

use steps

Suite status: <idle, ready to run>

Experimental features:

Fastest: N/A

Slowest: N/A

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