14.2 Math Object

Overview

The Math object in JavaScript provides a collection of properties and methods for mathematical constants and functions. Unlike other global objects, Math is not a constructor—you use its methods directly.

Math Object Structure

┌─────────────────────────────────────────────────────────────────┐
│                        Math Object                               │
├─────────────────────────────────────────────────────────────────┤
│  Not a constructor - cannot use 'new Math()'                    │
│  All properties and methods are static                          │
├─────────────────────────────────────────────────────────────────┤
│                                                                  │
│  ┌─────────────────┐    ┌─────────────────────────────────────┐ │
│  │   Constants     │    │           Methods                   │ │
│  ├─────────────────┤    ├─────────────────────────────────────┤ │
│  │ Math.PI         │    │ Rounding: round, floor, ceil, trunc │ │
│  │ Math.E          │    │ Min/Max: min, max                   │ │
│  │ Math.LN2        │    │ Random: random                      │ │
│  │ Math.LN10       │    │ Power: pow, sqrt, cbrt, hypot       │ │
│  │ Math.LOG2E      │    │ Trig: sin, cos, tan, asin, etc.     │ │
│  │ Math.LOG10E     │    │ Log: log, log2, log10               │ │
│  │ Math.SQRT2      │    │ Other: abs, sign, exp, expm1        │ │
│  │ Math.SQRT1_2    │    │                                     │ │
│  └─────────────────┘    └─────────────────────────────────────┘ │
│                                                                  │
└─────────────────────────────────────────────────────────────────┘

Mathematical Constants

Constant	Approximate Value	Description
`Math.PI`	3.14159...	Ratio of circumference to diameter
`Math.E`	2.71828...	Euler's number (natural log base)
`Math.LN2`	0.69314...	Natural logarithm of 2
`Math.LN10`	2.30258...	Natural logarithm of 10
`Math.LOG2E`	1.44269...	Base-2 logarithm of E
`Math.LOG10E`	0.43429...	Base-10 logarithm of E
`Math.SQRT2`	1.41421...	Square root of 2
`Math.SQRT1_2`	0.70710...	Square root of 1/2

console.log(Math.PI); // 3.141592653589793
console.log(Math.E); // 2.718281828459045
console.log(Math.SQRT2); // 1.4142135623730951

Rounding Methods

┌─────────────────────────────────────────────────────────────────┐
│                     Rounding Methods                             │
├─────────────────────────────────────────────────────────────────┤
│                                                                  │
│   Number Line:    -3    -2    -1     0     1     2     3        │
│                    ├─────┼─────┼─────┼─────┼─────┼─────┤        │
│                                                                  │
│   For 2.7:                                                       │
│   ─────────────────────────────────────────────────────────────  │
│   floor(2.7) = 2    ←── rounds toward -∞                        │
│   ceil(2.7) = 3     ←── rounds toward +∞                        │
│   round(2.7) = 3    ←── rounds to nearest (0.5 rounds up)       │
│   trunc(2.7) = 2    ←── removes decimal part                    │
│                                                                  │
│   For -2.7:                                                      │
│   ─────────────────────────────────────────────────────────────  │
│   floor(-2.7) = -3  ←── rounds toward -∞                        │
│   ceil(-2.7) = -2   ←── rounds toward +∞                        │
│   round(-2.7) = -3  ←── rounds to nearest                       │
│   trunc(-2.7) = -2  ←── removes decimal part                    │
│                                                                  │
└─────────────────────────────────────────────────────────────────┘

// Math.round() - rounds to nearest integer
Math.round(2.4); // 2
Math.round(2.5); // 3
Math.round(2.6); // 3
Math.round(-2.5); // -2 (rounds toward +∞ at .5)

// Math.floor() - rounds down (toward -∞)
Math.floor(2.9); // 2
Math.floor(-2.1); // -3

// Math.ceil() - rounds up (toward +∞)
Math.ceil(2.1); // 3
Math.ceil(-2.9); // -2

// Math.trunc() - removes decimal part
Math.trunc(2.9); // 2
Math.trunc(-2.9); // -2

Rounding to Decimal Places

// Round to N decimal places
function roundTo(num, decimals) {
  const factor = Math.pow(10, decimals);
  return Math.round(num * factor) / factor;
}

roundTo(3.14159, 2); // 3.14
roundTo(3.14159, 4); // 3.1416

// Floor/Ceil to decimal places
function floorTo(num, decimals) {
  const factor = Math.pow(10, decimals);
  return Math.floor(num * factor) / factor;
}

function ceilTo(num, decimals) {
  const factor = Math.pow(10, decimals);
  return Math.ceil(num * factor) / factor;
}

Min and Max

// Find minimum and maximum
Math.min(1, 2, 3); // 1
Math.max(1, 2, 3); // 3

// With negative numbers
Math.min(-1, -5, 0); // -5
Math.max(-1, -5, 0); // 0

// With arrays (use spread operator)
const numbers = [5, 2, 8, 1, 9];
Math.min(...numbers); // 1
Math.max(...numbers); // 9

// Edge cases
Math.min(); // Infinity
Math.max(); // -Infinity
Math.min(1, NaN, 3); // NaN

Random Numbers

┌─────────────────────────────────────────────────────────────────┐
│                     Math.random()                                │
├─────────────────────────────────────────────────────────────────┤
│                                                                  │
│   Returns: 0 ≤ x < 1  (0 inclusive, 1 exclusive)                │
│                                                                  │
│   ├────────────────────────────────────────────────────────┤    │
│   0                                                        1    │
│   ▲                                                              │
│   included                               not included ──────▶   │
│                                                                  │
└─────────────────────────────────────────────────────────────────┘

// Basic random (0 to 1)
Math.random(); // e.g., 0.7234589012

// Random integer from 0 to max (exclusive)
function randomInt(max) {
  return Math.floor(Math.random() * max);
}
randomInt(10); // 0-9

// Random integer in range [min, max] (inclusive)
function randomRange(min, max) {
  return Math.floor(Math.random() * (max - min + 1)) + min;
}
randomRange(1, 6); // 1-6 (dice roll)
randomRange(10, 20); // 10-20

// Random float in range
function randomFloat(min, max) {
  return Math.random() * (max - min) + min;
}
randomFloat(1.5, 3.5); // 1.5-3.5

// Random boolean
function randomBool() {
  return Math.random() < 0.5;
}

// Random array element
function randomElement(arr) {
  return arr[Math.floor(Math.random() * arr.length)];
}
randomElement(['a', 'b', 'c']); // Random pick

// Shuffle array (Fisher-Yates)
function shuffle(arr) {
  const result = [...arr];
  for (let i = result.length - 1; i > 0; i--) {
    const j = Math.floor(Math.random() * (i + 1));
    [result[i], result[j]] = [result[j], result[i]];
  }
  return result;
}

Power and Root Methods

Method	Description	Example
`Math.pow(x, y)`	x raised to power y	`Math.pow(2, 3) → 8`
`Math.sqrt(x)`	Square root	`Math.sqrt(16) → 4`
`Math.cbrt(x)`	Cube root	`Math.cbrt(27) → 3`
`Math.hypot(...values)`	Hypotenuse	`Math.hypot(3, 4) → 5`
`**` operator	Power (ES2016)	`2 ** 3 → 8`

// Powers
Math.pow(2, 3); // 8 (2³)
Math.pow(2, 0.5); // 1.414... (square root)
2 ** 3; // 8 (ES2016 operator)
2 ** -1; // 0.5

// Roots
Math.sqrt(16); // 4
Math.sqrt(-1); // NaN
Math.cbrt(27); // 3
Math.cbrt(-8); // -2

// Hypotenuse (Pythagorean theorem)
Math.hypot(3, 4); // 5 (√(3² + 4²))
Math.hypot(5, 12); // 13

// Distance between two points
function distance(x1, y1, x2, y2) {
  return Math.hypot(x2 - x1, y2 - y1);
}
distance(0, 0, 3, 4); // 5

Absolute Value and Sign

// Absolute value
Math.abs(-5); // 5
Math.abs(5); // 5
Math.abs(-3.14); // 3.14

// Sign (returns -1, 0, or 1)
Math.sign(-5); // -1
Math.sign(0); // 0
Math.sign(5); // 1
Math.sign(-0); // -0

Exponential and Logarithmic

┌─────────────────────────────────────────────────────────────────┐
│              Exponential and Logarithmic Functions              │
├─────────────────────────────────────────────────────────────────┤
│                                                                  │
│   Exponential:                    Logarithmic:                  │
│   ─────────────                   ────────────                  │
│   Math.exp(x) = eˣ                Math.log(x) = ln(x)           │
│   Math.expm1(x) = eˣ - 1          Math.log1p(x) = ln(1 + x)     │
│                                   Math.log2(x) = log₂(x)        │
│                                   Math.log10(x) = log₁₀(x)      │
│                                                                  │
│   Relationship: if y = eˣ then x = ln(y)                        │
│                                                                  │
└─────────────────────────────────────────────────────────────────┘

// Exponential
Math.exp(1); // 2.718... (e¹)
Math.exp(2); // 7.389... (e²)
Math.expm1(0); // 0 (e⁰ - 1)

// Natural logarithm (base e)
Math.log(Math.E); // 1
Math.log(1); // 0
Math.log(0); // -Infinity
Math.log(-1); // NaN

// Other logarithms
Math.log2(8); // 3 (2³ = 8)
Math.log10(1000); // 3 (10³ = 1000)

// Custom base logarithm
function logBase(x, base) {
  return Math.log(x) / Math.log(base);
}
logBase(8, 2); // 3

Trigonometric Functions

┌─────────────────────────────────────────────────────────────────┐
│                  Trigonometric Functions                         │
├─────────────────────────────────────────────────────────────────┤
│                                                                  │
│   NOTE: All angles are in RADIANS, not degrees!                 │
│                                                                  │
│   Conversion:                                                    │
│   ───────────                                                    │
│   radians = degrees × (π / 180)                                 │
│   degrees = radians × (180 / π)                                 │
│                                                                  │
│   Common Values:                                                 │
│   ──────────────                                                 │
│   0° = 0 rad       90° = π/2 rad                                │
│   180° = π rad     360° = 2π rad                                │
│                                                                  │
└─────────────────────────────────────────────────────────────────┘

Method	Description
`Math.sin(x)`	Sine of x (radians)
`Math.cos(x)`	Cosine of x
`Math.tan(x)`	Tangent of x
`Math.asin(x)`	Arcsine (inverse sine)
`Math.acos(x)`	Arccosine
`Math.atan(x)`	Arctangent
`Math.atan2(y, x)`	Arctangent of y/x
`Math.sinh(x)`	Hyperbolic sine
`Math.cosh(x)`	Hyperbolic cosine
`Math.tanh(x)`	Hyperbolic tangent

// Degree/Radian conversion
function toRadians(degrees) {
  return degrees * (Math.PI / 180);
}

function toDegrees(radians) {
  return radians * (180 / Math.PI);
}

// Basic trig functions
Math.sin(0); // 0
Math.sin(Math.PI / 2); // 1 (sin 90°)
Math.cos(0); // 1
Math.cos(Math.PI); // -1 (cos 180°)
Math.tan(Math.PI / 4); // 1 (tan 45°)

// Inverse trig functions
Math.asin(1); // 1.5707... (π/2)
Math.acos(0); // 1.5707... (π/2)
Math.atan(1); // 0.7853... (π/4)

// atan2 - angle from origin to point (y, x)
Math.atan2(1, 1); // 0.7853... (45°)
Math.atan2(1, 0); // 1.5707... (90°)

Other Useful Methods

Method	Description	Example
`Math.fround(x)`	Nearest 32-bit float	`Math.fround(1.5) → 1.5`
`Math.clz32(x)`	Leading zeros in 32-bit	`Math.clz32(1) → 31`
`Math.imul(a, b)`	32-bit integer multiply	`Math.imul(2, 4) → 8`

Practical Examples

Circle Calculations

function circleArea(radius) {
  return Math.PI * radius ** 2;
}

function circumference(radius) {
  return 2 * Math.PI * radius;
}

circleArea(5); // 78.539...
circumference(5); // 31.415...

Distance and Angles

// Distance between two points
function distance(x1, y1, x2, y2) {
  return Math.hypot(x2 - x1, y2 - y1);
}

// Angle between two points (in degrees)
function angle(x1, y1, x2, y2) {
  const radians = Math.atan2(y2 - y1, x2 - x1);
  return radians * (180 / Math.PI);
}

distance(0, 0, 3, 4); // 5
angle(0, 0, 1, 1); // 45

Clamping Values

function clamp(value, min, max) {
  return Math.min(Math.max(value, min), max);
}

clamp(150, 0, 100); // 100
clamp(-50, 0, 100); // 0
clamp(50, 0, 100); // 50

Linear Interpolation

function lerp(start, end, t) {
  return start + (end - start) * t;
}

lerp(0, 100, 0); // 0
lerp(0, 100, 0.5); // 50
lerp(0, 100, 1); // 100

Mapping Range

function mapRange(value, inMin, inMax, outMin, outMax) {
  return ((value - inMin) * (outMax - outMin)) / (inMax - inMin) + outMin;
}

mapRange(50, 0, 100, 0, 1); // 0.5
mapRange(25, 0, 100, 0, 255); // 63.75

Key Takeaways

┌─────────────────────────────────────────────────────────────────┐
│                       Math Object Summary                        │
├─────────────────────────────────────────────────────────────────┤
│  1. Math is not a constructor - use methods directly            │
│  2. Rounding: round, floor, ceil, trunc have different behavior │
│  3. Math.random() returns [0, 1) - includes 0, excludes 1       │
│  4. Trig functions use RADIANS, not degrees                     │
│  5. Use spread operator for min/max with arrays                 │
│  6. Math.hypot() is great for distance calculations             │
│  7. ES2016 ** operator is cleaner than Math.pow()               │
│  8. Math.sign() returns -1, 0, or 1                             │
└─────────────────────────────────────────────────────────────────┘

README