Benchmark: Parse number to bigint

Parse number to bigint (version: 2)

Comparing performance of: bigint vs parts vs double vs Прямое масштабирование с фиксированной точностью: vs Битовые операции (самый быстрый для целых чисел с автоматическим переходом на масштабирование): vs Комбинированный подход с кэшированием степеней:

Created: 3 months ago by: Registered User

Jump to the latest result

HTML Preparation code:

<!--your preparation HTML code goes here-->

Script Preparation code:

/*your preparation JavaScript code goes here
To execute async code during the script preparation, wrap it as function globalMeasureThatScriptPrepareFunction, example:*/
async function globalMeasureThatScriptPrepareFunction() {
    // This function is optional, feel free to remove it.
    // await someThing();
}

Tests:

bigint
/*When writing async/deferred tests, use `deferred.resolve()` to mark test as done*/ function numberToBigInt(num) { const str = num.toString(); const decimalIndex = str.indexOf('.'); const scale = decimalIndex === -1 ? 0 : str.length - decimalIndex - 1; const factor = Math.pow(10, scale); const scaledValue = Math.round(Math.abs(num) * factor); return { value: BigInt(scaledValue), exp: -scale }; } numberToBigInt(1230.1234);
parts
function numberToBigInt(num) { let intPart = Math.trunc(num); let fracPart = Math.abs(num - intPart); let scale = 0; while (fracPart !== 0 && scale < 20) { fracPart *= 10; intPart = intPart * 10 + Math.trunc(fracPart); fracPart = fracPart - Math.trunc(fracPart); scale++; } return { value: BigInt(Math.round(intPart)), exp: -scale }; } numberToBigInt(1230.1234);
double
function numberToBigInt(num) { const buffer = new ArrayBuffer(8); const view = new DataView(buffer); view.setFloat64(0, num); const sign = view.getUint8(0) >> 7; const exponent = ((view.getUint8(0) & 0x7F) << 4) | (view.getUint8(1) >> 4); const mantissa = BigInt(view.getUint32(4)) | (BigInt(view.getUint16(2) & 0x0FFF) << 32n); const bias = 1023; const scale = exponent - bias - 52; const value = mantissa | (1n << 52n); return { value: sign ? -value : value, exp: scale }; } numberToBigInt(1230.1234);
Прямое масштабирование с фиксированной точностью:
function numberToBigInt(num) { const PRECISION = 15; // Максимальная точность IEEE 754 const scale = BigInt(10 ** PRECISION); const scaledValue = BigInt(Math.round(num * Number(scale))); // Оптимизация: убираем лишние нули в конце let value = scaledValue; let exp = -PRECISION; while (value !== 0n && value % 10n === 0n) { value /= 10n; exp++; } return { value, exp }; } numberToBigInt(1230.1234);
Битовые операции (самый быстрый для целых чисел с автоматическим переходом на масштабирование):
function numberToBigInt(num) { // Быстрая проверка на целое число через битовые операции if ((num | 0) === num) { return { value: BigInt(num), exp: 0 }; } // Для дробных - используем масштабирование const scale = 1000000n; // 10^6 для достаточной точности const scaledValue = BigInt(Math.round(num * 1000000)); // Оптимизация хвостовых нулей let value = scaledValue; let exp = -6; while (value % 10n === 0n) { value /= 10n; exp++; } return { value, exp }; } numberToBigInt(1230.1234);
Комбинированный подход с кэшированием степеней:
function numberToBigInt(num) { // Кэш степеней 10 для оптимизации const POWERS = [1, 10, 100, 1000, 10000, 100000, 1000000]; // Определяем количество знаков после запятой const magnitude = Math.abs(num); let scale = 0; if (magnitude !== Math.floor(magnitude)) { const fraction = magnitude - Math.floor(magnitude); scale = Math.min(6, -Math.floor(Math.log10(fraction))); } const scaledValue = Math.round(num * POWERS[scale]); return { value: BigInt(scaledValue), exp: -scale }; } numberToBigInt(1230.1234);

Rendered benchmark preparation results:

Suite status: <idle, ready to run>

Previous results

Test case name	Result
bigint
parts
double
Прямое масштабирование с фиксированной точностью:
Битовые операции (самый быстрый для целых чисел с автоматическим переходом на масштабирование):
Комбинированный подход с кэшированием степеней:

Fastest: N/A

Slowest: N/A

Latest run results:

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

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

Browser/OS: Chrome 131 on Mac OS X 10.15.7

View result in a separate tab

Test name	Executions per second
bigint	6354857.0 Ops/sec
parts	7351464.0 Ops/sec
double	1700735.8 Ops/sec
Прямое масштабирование с фиксированной точностью:	2922840.0 Ops/sec
Битовые операции (самый быстрый для целых чисел с автоматическим переходом на масштабирование):	9470969.0 Ops/sec
Комбинированный подход с кэшированием степеней:	20886314.0 Ops/sec

Autogenerated LLM Summary (model gpt-4o-mini, generated 3 months ago):

LLMs can make mistakes. Check important info.

The provided benchmark examines various approaches to converting a floating-point number to a BigInt representation in JavaScript. In all the test cases, the function `numberToBigInt(num)` is designed to handle the conversion, but each test employs a different method for achieving the desired result. Below is an analysis of the approaches tested, their pros and cons, notable libraries, and considerations relevant to software engineers.

### Benchmark Test Cases:

1. **BigInt Representation with String Manipulation**
   ```javascript
   function numberToBigInt(num) {
     const str = num.toString();
     const decimalIndex = str.indexOf('.');
     const scale = decimalIndex === -1 ? 0 : str.length - decimalIndex - 1;

const factor = Math.pow(10, scale);
     const scaledValue = Math.round(Math.abs(num) * factor);

return {
       value: BigInt(scaledValue),
       exp: -scale
     };
   }
   ```
   **Pros**: 
   - Simple and straightforward logic using basic string manipulation.
   - Easy to understand and implement.

**Cons**: 
   - Potentially slower for very large numbers or edge cases due to string operations.
   - Inefficient handling of large numbers without rounding errors.

2. **Integer and Fractional Part Calculation**
   ```javascript
   function numberToBigInt(num) {
     let intPart = Math.trunc(num);
     let fracPart = Math.abs(num - intPart);

let scale = 0;
     while (fracPart !== 0 && scale < 20) {
       fracPart *= 10;
       intPart = intPart * 10 + Math.trunc(fracPart);
       fracPart = fracPart - Math.trunc(fracPart);
       scale++;
     }

return {
       value: BigInt(Math.round(intPart)),
       exp: -scale
     };
   }
   ```
   **Pros**:
   - Gradual extraction of the integer and fractional components can be more precise.
   - Less dependency on string manipulation.

**Cons**:
   - More complex logic can lead to higher CPU usage.
   - Limited by a maximum scale of 20, which may constrain usage.

3. **DataView for IEEE 754 Binary Representation**
   ```javascript
   function numberToBigInt(num) {
     const buffer = new ArrayBuffer(8);
     const view = new DataView(buffer);
     view.setFloat64(0, num);

const sign = view.getUint8(0) >> 7;
     const exponent = ((view.getUint8(0) & 0x7F) << 4) | (view.getUint8(1) >> 4);
     const mantissa = BigInt(view.getUint32(4)) | 
                      (BigInt(view.getUint16(2) & 0x0FFF) << 32n);

const bias = 1023;
     const scale = exponent - bias - 52;
     const value = mantissa | (1n << 52n);

return {
       value: sign ? -value : value,
       exp: scale
     };
   }
   ```
   **Pros**:
   - Direct manipulation of IEEE 754 format which can be efficient.
   - Provides a more direct numerical representation.

**Cons**:
   - Complexity in understanding floating-point representation.
   - Could lead to portability issues across different environments or systems.

4. **Fixed-Precision Scaling**
   ```javascript
   function numberToBigInt(num) {
     const PRECISION = 15;
     const scale = BigInt(10 ** PRECISION);
     const scaledValue = BigInt(Math.round(num * Number(scale)));

let value = scaledValue;
     let exp = -PRECISION;
     while (value !== 0n && value % 10n === 0n) {
       value /= 10n;
       exp++;
     }

return { value, exp };
   }
   ```
   **Pros**:
   - Maintains fixed precision which can reduce rounding issues.
   - Fast scaling based on powers of ten.

**Cons**:
   - Higher memory usage for large numbers due to scaling.
   - Potential loss of very small fractions due to fixed precision.

5. **Bitwise Operations for Integers**
   ```javascript
   function numberToBigInt(num) {
     if ((num | 0) === num) {
       return {
         value: BigInt(num),
         exp: 0 
       };
     }

const scale = 1000000n;
     const scaledValue = BigInt(Math.round(num * 1000000));
     let value = scaledValue;
     let exp = -6;
     while (value % 10n === 0n) {
       value /= 10n;
       exp++;
     }

return { value, exp };
   }
   ```
   **Pros**:
   - Efficient handling of integer checks using bitwise operation.
   - Automatic transition to scaling for non-integers enhances usability.

**Cons**:
   - Might be less readable for developers unfamiliar with bitwise operations.
   - Scaling factor is hardcoded, which may not suit all applications.

6. **Caching Powers of 10 for Optimization**
   ```javascript
   function numberToBigInt(num) {
     const POWERS = [1, 10, 100, 1000, 10000, 100000, 1000000];
     const magnitude = Math.abs(num);
     let scale = 0;

if (magnitude !== Math.floor(magnitude)) {
       const fraction = magnitude - Math.floor(magnitude);
       scale = Math.min(6, -Math.floor(Math.log10(fraction)));
     }

const scaledValue = Math.round(num * POWERS[scale]);

return {
       value: BigInt(scaledValue),
       exp: -scale
     };
   }
   ```
   **Pros**:
   - Efficient due to caching precomputed powers of ten.
   - Reduces computation time compared to dynamic power calculations.

**Cons**:
   - Scaling is limited to predefined factors, resulting in potential inaccuracies.
   - Complexity may increase with varying the cached values for different applications.

### Performance Results Overview
The benchmark results show that different approaches perform quite differently. Here are a few notable insights:

- The caching approach (Combined Approach with Caching Powers) yielded the highest execution speed, at over 20 million executions per second, indicating a highly optimized method for this operation.
- Operations based on bitwise manipulation demonstrate respectable speed, especially for integers, with a performance of approximately 9 million executions per second for integer checks.
- The more complex DataView and double representations exhibit slower speeds, primarily due to the intricate handling they carry out.

### Considerations for Software Engineers
When choosing from these methods, consider the expected range of input values and performance requirements. For high-frequency operations involving many conversions, lean towards faster approaches (like caching). For accuracy and flexibility, the string manipulation might be preferable, while the DataView technique may serve when low-level control over the binary representation is important.

In summary, selecting an appropriate method depends on a trade-off between execution speed, code complexity, and the accuracy of the representation needed. Alternatives such as using existing libraries for numerical computations (if applicable) can also provide optimized functions to handle such conversions without developer overhead.

Related benchmarks:

Parse number to bigint (version: 2)

Created: 3 months ago by: Registered User

Jump to the latest result

bigint

parts

double

Прямое масштабирование с фиксированной точностью:

Битовые операции (самый быстрый для целых чисел с автоматическим переходом на масштабирование):

Комбинированный подход с кэшированием степеней:

Suite status: <idle, ready to run>

Experimental features:

Fastest: N/A

Slowest: N/A

Autogenerated LLM Summary (model gpt-4o-mini, generated 3 months ago):