Math Built-ins - Porffor

Porffor implements the full Math API for mathematical operations.

Math Constants

Math.E

Euler’s number (approximately 2.718).

console.log(Math.E);  // 2.718281828459045

Math.LN2

Natural logarithm of 2 (approximately 0.693).

console.log(Math.LN2);  // 0.6931471805599453

Math.LN10

Natural logarithm of 10 (approximately 2.303).

console.log(Math.LN10);  // 2.302585092994046

Math.LOG2E

Base-2 logarithm of E (approximately 1.443).

console.log(Math.LOG2E);  // 1.4426950408889634

Math.LOG10E

Base-10 logarithm of E (approximately 0.434).

console.log(Math.LOG10E);  // 0.4342944819032518

Math.PI

Pi (approximately 3.14159).

console.log(Math.PI);  // 3.141592653589793

Math.SQRT1_2

Square root of 1/2 (approximately 0.707).

console.log(Math.SQRT1_2);  // 0.7071067811865476

Math.SQRT2

Square root of 2 (approximately 1.414).

console.log(Math.SQRT2);  // 1.4142135623730951

Basic Operations

Math.abs

Returns absolute value.

Math.abs(x: number): number

console.log(Math.abs(-5));     // 5
console.log(Math.abs(3.14));   // 3.14
console.log(Math.abs(-0));     // 0

Math.sign

Returns sign of a number (-1, 0, or 1).

Math.sign(x: number): number

console.log(Math.sign(-5));    // -1
console.log(Math.sign(0));     // 0
console.log(Math.sign(5));     // 1

Math.ceil

Rounds up to nearest integer.

Math.ceil(x: number): number

console.log(Math.ceil(4.2));   // 5
console.log(Math.ceil(4.8));   // 5
console.log(Math.ceil(-4.2));  // -4

Math.floor

Rounds down to nearest integer.

Math.floor(x: number): number

console.log(Math.floor(4.2));   // 4
console.log(Math.floor(4.8));   // 4
console.log(Math.floor(-4.2));  // -5

Math.round

Rounds to nearest integer.

Math.round(x: number): number

console.log(Math.round(4.2));   // 4
console.log(Math.round(4.5));   // 5
console.log(Math.round(4.8));   // 5
console.log(Math.round(-4.5));  // -4

Math.trunc

Removes fractional part.

Math.trunc(x: number): number

console.log(Math.trunc(4.8));   // 4
console.log(Math.trunc(-4.8));  // -4

Min/Max

Math.min

Returns smallest value.

Math.min(...values: number[]): number

console.log(Math.min(1, 2, 3));        // 1
console.log(Math.min(-5, 0, 5));       // -5
console.log(Math.min());               // Infinity

Math.max

Returns largest value.

Math.max(...values: number[]): number

console.log(Math.max(1, 2, 3));        // 3
console.log(Math.max(-5, 0, 5));       // 5
console.log(Math.max());               // -Infinity

Power and Root

Math.pow

Returns base to the exponent power.

Math.pow(base: number, exponent: number): number

console.log(Math.pow(2, 3));   // 8
console.log(Math.pow(4, 0.5)); // 2
console.log(Math.pow(2, -1));  // 0.5

Math.sqrt

Returns square root.

Math.sqrt(x: number): number

console.log(Math.sqrt(4));     // 2
console.log(Math.sqrt(9));     // 3
console.log(Math.sqrt(2));     // 1.4142135623730951
console.log(Math.sqrt(-1));    // NaN

Math.cbrt

Returns cube root.

Math.cbrt(x: number): number

console.log(Math.cbrt(8));     // 2
console.log(Math.cbrt(27));    // 3
console.log(Math.cbrt(-8));    // -2

Math.hypot

Returns square root of sum of squares.

Math.hypot(...values: number[]): number

console.log(Math.hypot(3, 4));      // 5
console.log(Math.hypot(5, 12));     // 13
console.log(Math.hypot(1, 2, 3));   // 3.7416573867739413

Exponential and Logarithmic

Math.exp

Returns e raised to a power.

Math.exp(x: number): number

console.log(Math.exp(0));      // 1
console.log(Math.exp(1));      // 2.718281828459045 (Math.E)
console.log(Math.exp(2));      // 7.38905609893065

Math.expm1

Returns e^x - 1.

Math.expm1(x: number): number

console.log(Math.expm1(0));    // 0
console.log(Math.expm1(1));    // 1.718281828459045

Math.log

Returns natural logarithm.

Math.log(x: number): number

console.log(Math.log(Math.E)); // 1
console.log(Math.log(10));     // 2.302585092994046
console.log(Math.log(1));      // 0

Math.log10

Returns base-10 logarithm.

Math.log10(x: number): number

console.log(Math.log10(10));   // 1
console.log(Math.log10(100));  // 2
console.log(Math.log10(1000)); // 3

Math.log2

Returns base-2 logarithm.

Math.log2(x: number): number

console.log(Math.log2(2));     // 1
console.log(Math.log2(8));     // 3
console.log(Math.log2(1024));  // 10

Math.log1p

Returns ln(1 + x).

Math.log1p(x: number): number

console.log(Math.log1p(0));    // 0
console.log(Math.log1p(1));    // 0.6931471805599453

Trigonometric

Math.sin

Returns sine.

Math.sin(x: number): number

console.log(Math.sin(0));              // 0
console.log(Math.sin(Math.PI / 2));    // 1
console.log(Math.sin(Math.PI));        // ~0

Math.cos

Returns cosine.

Math.cos(x: number): number

console.log(Math.cos(0));              // 1
console.log(Math.cos(Math.PI / 2));    // ~0
console.log(Math.cos(Math.PI));        // -1

Math.tan

Returns tangent.

Math.tan(x: number): number

console.log(Math.tan(0));              // 0
console.log(Math.tan(Math.PI / 4));    // ~1

Math.asin

Returns arcsine.

Math.asin(x: number): number

console.log(Math.asin(0));     // 0
console.log(Math.asin(1));     // 1.5707963267948966 (PI/2)
console.log(Math.asin(-1));    // -1.5707963267948966

Math.acos

Returns arccosine.

Math.acos(x: number): number

console.log(Math.acos(1));     // 0
console.log(Math.acos(0));     // 1.5707963267948966 (PI/2)
console.log(Math.acos(-1));    // 3.141592653589793 (PI)

Math.atan

Returns arctangent.

Math.atan(x: number): number

console.log(Math.atan(0));     // 0
console.log(Math.atan(1));     // 0.7853981633974483 (PI/4)

Math.atan2

Returns arctangent of quotient.

Math.atan2(y: number, x: number): number

console.log(Math.atan2(1, 1));    // 0.7853981633974483 (PI/4)
console.log(Math.atan2(1, 0));    // 1.5707963267948966 (PI/2)
console.log(Math.atan2(0, -1));   // 3.141592653589793 (PI)

Math.sinh

Returns hyperbolic sine.

Math.sinh(x: number): number

Math.cosh

Returns hyperbolic cosine.

Math.cosh(x: number): number

Math.tanh

Returns hyperbolic tangent.

Math.tanh(x: number): number

Math.asinh

Returns hyperbolic arcsine.

Math.asinh(x: number): number

Math.acosh

Returns hyperbolic arccosine.

Math.acosh(x: number): number

Math.atanh

Returns hyperbolic arctangent.

Math.atanh(x: number): number

Random

Math.random

Returns a random number between 0 (inclusive) and 1 (exclusive).

Math.random(): number

console.log(Math.random());  // e.g., 0.4536271829

// Random integer between min and max (inclusive)
function randomInt(min, max) {
  return Math.floor(Math.random() * (max - min + 1)) + min;
}

console.log(randomInt(1, 10));  // e.g., 7

Bitwise Operations

Math.clz32

Returns number of leading zero bits in 32-bit binary representation.

Math.clz32(x: number): number

console.log(Math.clz32(1));        // 31
console.log(Math.clz32(1000));     // 22
console.log(Math.clz32(0));        // 32

Math.imul

Returns 32-bit integer multiplication.

Math.imul(a: number, b: number): number

console.log(Math.imul(2, 4));      // 8
console.log(Math.imul(0xffffffff, 5)); // -5

Math.fround

Returns nearest 32-bit float representation.

Math.fround(x: number): number

console.log(Math.fround(1.5));     // 1.5
console.log(Math.fround(1.337));   // 1.3370000123977661

Usage Examples

Circle Calculations

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

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

console.log(circleArea(5));           // 78.53981633974483
console.log(circleCircumference(5));  // 31.41592653589793

Distance Calculation

function distance(x1, y1, x2, y2) {
  return Math.hypot(x2 - x1, y2 - y1);
}

console.log(distance(0, 0, 3, 4));  // 5

Clamping Values

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

console.log(clamp(5, 0, 10));   // 5
console.log(clamp(-5, 0, 10));  // 0
console.log(clamp(15, 0, 10));  // 10

Lerp (Linear Interpolation)

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

console.log(lerp(0, 100, 0.5));   // 50
console.log(lerp(0, 100, 0.25));  // 25
console.log(lerp(0, 100, 0.75));  // 75

Compiler API

Porffor Global API

Built-in APIs

​Math Constants

​Math.E

​Math.LN2

​Math.LN10

​Math.LOG2E

​Math.LOG10E

​Math.PI

​Math.SQRT1_2

​Math.SQRT2

​Basic Operations

​Math.abs

​Math.sign

​Math.ceil

​Math.floor

​Math.round

​Math.trunc

​Min/Max

​Math.min

​Math.max

​Power and Root

​Math.pow

​Math.sqrt

​Math.cbrt

​Math.hypot

​Exponential and Logarithmic

​Math.exp

​Math.expm1

​Math.log

​Math.log10

​Math.log2

​Math.log1p

​Trigonometric

​Math.sin

​Math.cos

​Math.tan

​Math.asin

​Math.acos

​Math.atan

​Math.atan2

​Math.sinh

​Math.cosh

​Math.tanh

​Math.asinh

​Math.acosh

​Math.atanh

​Random

​Math.random

​Bitwise Operations

​Math.clz32

​Math.imul

​Math.fround

​Usage Examples

​Circle Calculations

​Distance Calculation

​Clamping Values

​Lerp (Linear Interpolation)

​See Also

Build docs developers (and LLMs) love