Benchmark: Math.abs speed vs multiply vs steps mid point vs epsilon

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
    value = Math.round(value * 1000000) / 1000000
    step = Math.round(step * 1000000) / 1000000
    min = Math.round(min * 1000000) / 1000000

    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
    value = Math.round(value * 1000000) / 1000000
    step = Math.round(step * 1000000) / 1000000
    min = Math.round(min * 1000000) / 1000000

    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
}

function validateStepWithStepsMid(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 = 0.5 - Math.abs(remainder - 0.5)
    return remainder < 0.000001
}

function validateStep(value, step, min) {
    if (value < min) {
        return false;
    }
    var diff = (value - min) % step;
    var epsilon = 0.00001; // a small tolerance
    return diff < epsilon || step - diff < epsilon;
}

Tests:

Math.abs(x)
validateStepWithAbs(value, step, min)
compare x*x
validateStepWithMultiply(value, step, min)
use steps
validateStepWithSteps(value, step, min)
normilized
validateStepWithStepsMid(value, step, min)
Epsilon
validateStep(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
normilized
Epsilon

Fastest: N/A

Slowest: N/A

Latest run results:

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

User agent: Mozilla/5.0 (Linux; Android 10; K) AppleWebKit/537.36 (KHTML, like Gecko) Chrome/115.0.0.0 Mobile Safari/537.36

Browser/OS: Chrome Mobile 115 on Android

View result in a separate tab

Test name	Executions per second
Math.abs(x)	123631.1 Ops/sec
compare x*x	336531.4 Ops/sec
use steps	551901.3 Ops/sec
normilized	548876.0 Ops/sec
Epsilon	717432.8 Ops/sec

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

LLMs can make mistakes. Check important info.

Let's dive into the benchmark definition and options.

**Overview**

The provided JSON represents a JavaScript microbenchmarking test case on MeasureThat.net. The test is designed to compare the performance of different approaches to validate whether a given value `x` can be represented exactly as an integer within a certain tolerance or range.

**Benchmark Definition**

The benchmark definition consists of five functions:

1. `validateStepWithAbs(value, step, min)`: This function uses the absolute value function (`Math.abs`) to compare if `value` is close enough to `min + k * step`, where `k` is an integer.
2. `validateStepWithMultiply(value, step, min)`: This function squares `value` and compares it with `(min + k * step)^2`.
3. `validateStepWithSteps(value, step, min)`: This function calculates the number of steps required to reach `min` from `value`, and checks if this number is an integer.
4. `validateStepWithStepsMid(value, step, min)`: This function adjusts the result of `validateStepWithSteps` by rounding it to a fixed decimal precision (0.5).
5. `validateStep(value, step, min)`: This function uses an epsilon value (a small tolerance) to compare if `value` is close enough to `min + k * step`.

**Comparison Options**

The five functions are compared in the test cases:

1. `Math.abs(x)`
2. `x*x`
3. `use steps`
4. `normilized` ( likely a typo, and it should be "normalized")
5. `Epsilon`

**Pros and Cons of each approach:**

1. `validateStepWithAbs(value, step, min)`: This function is straightforward but may not work well for very large values or precise calculations.
	* Pros: Easy to implement and understand.
	* Cons: May be slow due to repeated absolute value computations.
2. `validateStepWithMultiply(value, step, min)`: Squaring `value` can introduce precision errors.
	* Pros: Can be faster than using absolute values, as squaring is often more efficient.
	* Cons: May not work well for very large or precise values.
3. `validateStepWithSteps(value, step, min)`: This approach is more accurate but may be slower due to repeated division and modulo operations.
	* Pros: Highly accurate, especially for large values.
	* Cons: May be slow due to the complexity of the calculation.
4. `validateStepWithStepsMid(value, step, min)`: Adjusting the result by rounding it to a fixed decimal precision can introduce errors.
	* Pros: Simplifies the implementation and can be faster than `validateStepWithSteps`.
	* Cons: May not work well for very precise calculations or large values.
5. `validateStep(value, step, min)`: Using an epsilon value provides a balance between accuracy and speed.
	* Pros: Offers a good balance between precision and performance.
	* Cons: May introduce errors if the epsilon value is too small.

**Device-Specific Results**

The latest benchmark result shows that Chrome Mobile 115 on Android performs best for the `Epsilon` test, followed by `use steps`. This suggests that using an epsilon value provides a good balance between precision and performance for this specific test case.

Related benchmarks:

Math.abs speed vs multiply vs steps mid point vs epsilon (version: 0)

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

Created: one year ago by: Guest

Jump to the latest result

Math.abs(x)

compare x*x

use steps

normilized

Epsilon

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