@bignum/template-light

Write formulas with template literals. (light version)

This is the light version of @bignum/template. It has significantly more limited functionality than @bignum/template, but is much smaller.

🚀 Features

• You can write formulas with template literals.
  (f`${0.3} - ${0.1}` is easier to read than a statement like new MyNum(0.3).minus(0.1).)
• Prevent rounding errors by calculating with rational numbers using BigInt.
• It has no dependencies and can be minified to 2.3 KB (Minified and gzipped: 1.1 KB) .
• You can pre-compile expressions using @bignum/babel-plugin, which reduces the runtime library size to 1.1 KB (Minified and gzipped: 0.6 KB) .
• Repeated calls from the same tagged template callsite reuse the compiled expression at runtime.

Note that although no rounding is performed during calculations, the calculation results are returned to Number, so values that cannot be held by Number may be rounded.

If you want more operations and more rounding avoidance, consider using @bignum/template.

💿 Installation

npm install @bignum/template-light

📖 Usage

import { f } from "@bignum/template-light";

const result = f`${0.1} + ${0.1} * ${2}`;
console.log(result); // 0.3

// Prevent rounding errors by calculating with rational numbers using BigInt.
console.log(f`${0.2} + ${0.1}`); // 0.3
console.log(0.2 + 0.1); // 0.30000000000000004

🧮 API

f

Perform calculations using template literals.

Example:

import { f } from "@bignum/template-light";

console.log(f`${0.1} + ${0.2}`); // 0.3

Repeated evaluation from the same tagged template callsite reuses the compiled expression. Different callsites are cached independently.

📝 Supported Syntax

Operators

The following operators are supported:

/* Arithmetic Operators */
// add
f`${0.1} + ${0.2}`; // 0.3
// subtract
f`${0.3} - ${0.1}`; // 0.2
// multiply
f`${0.07} * ${100}`; // 7
// divide
f`${0.6} / ${0.2}`; // 3
// modulo
f`${0.6} % ${0.2}`; // 0

/* Parentheses */
f`(${0.1} + ${0.2}) * ${10}`; // 3
f`${0.1} + ${0.2} * ${10}`; // 2.1

Operand

Substitutions in the template literal are treated as operands.

f`${0.2} + ${0.1}`; // 0.3