Using Rust and WebAssembly to Handle High-Precision Arithmetic

When dealing with large numbers in JavaScript, floating-point precision limitations often lead to unexpected results. To overcome these constraints, developers can leverage Rust compiled to WebAssembly (WASM) for accurate calculations.

Setting Up the Project

Begin by initializing a new Rust project with the wasm-pack tool:

wasm-pack init

Add the necessary dependency to Cargo.toml:

[dependencies]
wasm-bindgen = "0.2"

Implementing Mathematical Operasions

Create or modify src/lib.rs to define functions using the #[wasm_bindgen] attribute:

use wasm_bindgen::prelude::*;

#[wasm_bindgen]
pub fn sum(left: f64, right: f64) -> f64 {
    left + right
}

#[wasm_bindgen]
pub fn difference(minuend: f64, subtrahend: f64) -> f64 {
    minuend - subtrahend
}

#[wasm_bindgen]
pub fn product(factor_a: f64, factor_b: f64) -> f64 {
    factor_a * factor_b
}

#[wasm_bindgen]
pub fn quotient(dividend: f64, divisor: f64) -> f64 {
    if divisor == 0.0 {
        panic!("Division by zero is not allowed");
    }
    dividend / divisor
}

These functions are exported to JavaScript through WASM bindings, enabling precise numerical operations.

Building the WASM Module

Compile the project using:

wasm-pack build --target web

This generates a pkg directory containing the WASM binary and JavaScript wrappers.

Integrating into JavaScript

Include the generated module in your HTML:

<script type="module">
  import init, { sum, difference, product, quotient } from './pkg/rust_wasm_math.js';

  async function run() {
    await init();
    console.log(sum(0.1, 0.2)); // Accurate result
    console.log(product(123456789.0, 987654321.0)); // Precise multiplication
  }

  run();
</script>

The WASM module allows JavaScript applications to perform high-precision arithmteic by offloading computations to Rust's native capabilities.