Math Expression Calculator Guide: JavaScript Math Reference & Scientific Computing

Whether you're a front-end developer working on data visualization, a back-end engineer implementing business algorithms, or a data analyst doing quick calculations, understanding math expression evaluation and JavaScript's Math functions is essential. This guide starts with the Math object basics and progresses to scientific computing techniques and expression parsing.

JavaScript Math Object Complete Reference

JavaScript's built-in Math object provides a rich set of mathematical constants and functions, available without any additional dependencies.

Mathematical Constants

Basic Arithmetic Functions

Trigonometric Functions

Logarithmic & Exponential Functions

Math.log(x)     // Natural logarithm ln(x)
Math.log2(x)    // Log base 2
Math.log10(x)   // Log base 10
Math.exp(x)     // e^x
Math.expm1(x)   // e^x - 1 (more precise for small x)

Floating-Point Precision Issues & Solutions

JavaScript uses IEEE 754 double-precision floating point, which causes some seemingly simple calculations to produce unexpected results:

0.1 + 0.2          // → 0.30000000000000004
0.1 + 0.2 === 0.3  // → false
9999999999999999    // → 10000000000000000

Solutions

1. Integer arithmetic—convert decimals to integers first:

function add(a, b) {
  const factor = 10 ** 10;
  return (Math.round(a * factor) + Math.round(b * factor)) / factor;
}
add(0.1, 0.2)  // → 0.3

2. toFixed rounding—suitable for display:

(0.1 + 0.2).toFixed(2)  // → "0.30"
Number((0.1 + 0.2).toFixed(2))  // → 0.3

3. High-precision libraries—for financial calculations:

// decimal.js
import Decimal from 'decimal.js';
new Decimal(0.1).plus(0.2).toString()  // → "0.3"

Scientific Computing Techniques

Permutations & Combinations

// Factorial
function factorial(n) {
  if (n <= 1) return 1;
  let result = 1;
  for (let i = 2; i <= n; i++) result *= i;
  return result;
}

// Permutations P(n, k) = n! / (n-k)!
function permutation(n, k) {
  return factorial(n) / factorial(n - k);
}

// Combinations C(n, k) = n! / (k! * (n-k)!)
function combination(n, k) {
  return factorial(n) / (factorial(k) * factorial(n - k));
}

// Large-number combinations (prevents overflow)
function comb(n, k) {
  if (k > n - k) k = n - k;
  let result = 1;
  for (let i = 0; i < k; i++) {
    result = result * (n - i) / (i + 1);
  }
  return result;
}
comb(100, 3)  // → 161700

Statistical Functions

const data = [23, 45, 12, 67, 34, 89, 56];

// Mean
const mean = arr => arr.reduce((s, v) => s + v, 0) / arr.length;

// Median
const median = arr => {
  const sorted = [...arr].sort((a, b) => a - b);
  const mid = Math.floor(sorted.length / 2);
  return sorted.length % 2 ? sorted[mid] : (sorted[mid-1] + sorted[mid]) / 2;
};

// Standard deviation
const stddev = arr => {
  const m = mean(arr);
  return Math.sqrt(arr.reduce((s, v) => s + (v - m) ** 2, 0) / arr.length);
};

mean(data)    // → 46.57
median(data)  // → 45
stddev(data)  // → 25.26

Angle & Radian Conversion

const deg2rad = deg => deg * Math.PI / 180;
const rad2deg = rad => rad * 180 / Math.PI;

deg2rad(180)  // → 3.14159...
rad2deg(Math.PI)  // → 180

Linear Interpolation & Mapping

// Linear interpolation
function lerp(a, b, t) {
  return a + (b - a) * t;
}

// Map a value to a new range
function map(value, inMin, inMax, outMin, outMax) {
  return outMin + (value - inMin) * (outMax - outMin) / (inMax - inMin);
}

lerp(0, 100, 0.5)     // → 50
map(50, 0, 100, 0, 1)  // → 0.5

Distance Calculations

// Euclidean distance
const euclidean = (a, b) => Math.hypot(a[0]-b[0], a[1]-b[1]);

// Manhattan distance
const manhattan = (a, b) => Math.abs(a[0]-b[0]) + Math.abs(a[1]-b[1]);

// Haversine formula (distance between two points on Earth, in km)
function haversine(lat1, lon1, lat2, lon2) {
  const R = 6371;
  const dLat = (lat2 - lat1) * Math.PI / 180;
  const dLon = (lon2 - lon1) * Math.PI / 180;
  const a = Math.sin(dLat/2)**2 +
    Math.cos(lat1*Math.PI/180) * Math.cos(lat2*Math.PI/180) *
    Math.sin(dLon/2)**2;
  return R * 2 * Math.atan2(Math.sqrt(a), Math.sqrt(1-a));
}

Expression Evaluation & Parsing

Sometimes you need to parse and evaluate user-entered math expressions at runtime. Here are several common approaches:

Using the Function Constructor (Simple Cases)

function evaluate(expr) {
  return new Function('return ' + expr)();
}
evaluate('2 * (3 + 4)')  // → 14
evaluate('Math.sqrt(144)')  // → 12

Using the math.js Library

import { evaluate } from 'mathjs';

// Basic arithmetic
evaluate('2 + 3 * 4')  // → 14

// Variables
evaluate('x * y', { x: 3, y: 4 })  // → 12

// Functions
evaluate('sqrt(16) + sin(pi/2)')  // → 5

// Matrix operations
evaluate('det([[1, 2], [3, 4]])')  // → -2

// Unit conversion
evaluate('2 inch to cm')  // → 5.08 cm

FAQ