Num

const Num: object

Defined in: Data/Num.ts:20

Type Declaration

abs

abs: (n) => number

Returns the absolute value of a number.

Parameters

n

number

Returns

number

Example

pipe(-5, Num.abs); // 5
pipe(5, Num.abs);  // 5

add

add: (b) => (a) => number

Adds b to a number. Data-last: use in pipe or Arr.map.

Parameters

b

number

Returns

(a) => number

Example

pipe(5, Num.add(3));                   // 8
pipe([1, 2, 3], Arr.map(Num.add(10))); // [11, 12, 13]

between

between: (min, max) => (n) => boolean

Returns true when the number is between min and max (both inclusive).

Parameters

min

number

max

number

Returns

(n) => boolean

Example

pipe(5, Num.between(1, 10));  // true
pipe(0, Num.between(1, 10));  // false
pipe(10, Num.between(1, 10)); // true

ceil

ceil: (n) => number

Rounds a number up to the nearest integer.

Parameters

n

number

Returns

number

Example

pipe(3.1, Num.ceil); // 4
pipe(-3.9, Num.ceil); // -3

clamp

clamp: (min, max) => (n) => number

Clamps a number between min and max (both inclusive).

Parameters

min

number

max

number

Returns

(n) => number

Example

pipe(150, Num.clamp(0, 100)); // 100
pipe(-5, Num.clamp(0, 100));  // 0
pipe(42, Num.clamp(0, 100));  // 42

divide

divide: (b) => (a) => Maybe<number>

Divides a number by b. Returns None when b is zero. Data-last: divide(b)(a) = a / b.

Parameters

b

number

Returns

(a) => Maybe<number>

Example

pipe(20, Num.divide(4));                           // Some(5)
pipe(5, Num.divide(0));                            // None
pipe([10, 20, 30], Arr.filterMap(Num.divide(10))); // [1, 2, 3]

floor

floor: (n) => number

Rounds a number down to the nearest integer.

Parameters

n

number

Returns

number

Example

pipe(3.9, Num.floor); // 3
pipe(-3.2, Num.floor); // -4

format

format: (options?, locales?) => (n) => Maybe<string>

Formats a number using Intl.NumberFormat. Returns None when n is NaN or non-finite. Data-last curried signature.

Parameters

options?

NumberFormatOptions

locales?

string | string[]

Returns

(n) => Maybe<string>

Example

const formatCurrency = Num.format({ style: "currency", currency: "USD" }, "en-US");
pipe(1234.5, formatCurrency); // Some("$1,234.50")
pipe(NaN, formatCurrency);    // None

inRange

inRange: (start, end) => (n) => boolean

Returns true when the number is in the range [start, end) (inclusive of start, exclusive of end).

Parameters

start

number

end

number

Returns

(n) => boolean

Example

pipe(5, Num.inRange(1, 10));  // true
pipe(1, Num.inRange(1, 10));  // true
pipe(10, Num.inRange(1, 10)); // false

is

is: object

is.even

even: (n) => boolean

Returns true when the number is an even integer.

Parameters

n

number

Returns

boolean

Example

Num.is.even(4);   // true
Num.is.even(3);   // false
Num.is.even(2.5); // false

is.finite

finite: (n) => boolean

Returns true when the number is finite (not Infinity, -Infinity, or NaN).

Parameters

n

number

Returns

boolean

Example

Num.is.finite(42);       // true
Num.is.finite(Infinity); // false

is.float

float: (n) => boolean

Returns true when the number is a finite float (fractional number).

Parameters

n

number

Returns

boolean

Example

Num.is.float(3.14); // true
Num.is.float(5);    // false

is.integer

integer: (n) => boolean

Returns true when the number is a whole integer.

Parameters

n

number

Returns

boolean

Example

Num.is.integer(5);    // true
Num.is.integer(3.14); // false

is.nan

nan: (n) => boolean

Returns true when the value is NaN.

Parameters

n

number

Returns

boolean

Example

Num.is.nan(NaN); // true
Num.is.nan(42);  // false

is.negative

negative: (n) => boolean

Returns true when the number is strictly less than zero.

Parameters

n

number

Returns

boolean

Example

Num.is.negative(-5); // true
Num.is.negative(0);  // false
Num.is.negative(5);  // false

is.odd

odd: (n) => boolean

Returns true when the number is an odd integer.

Parameters

n

number

Returns

boolean

Example

Num.is.odd(3);   // true
Num.is.odd(4);   // false
Num.is.odd(2.5); // false

is.positive

positive: (n) => boolean

Returns true when the number is strictly greater than zero.

Parameters

n

number

Returns

boolean

Example

Num.is.positive(5);  // true
Num.is.positive(0);  // false
Num.is.positive(-5); // false

is.zero

zero: (n) => boolean

Returns true when the number is equal to zero.

Parameters

n

number

Returns

boolean

Example

Num.is.zero(0); // true
Num.is.zero(5); // false

max

max: (ns) => Maybe<number>

Computes the maximum of a list of numbers. Returns None if the list is empty.

Parameters

ns

readonly number[]

Returns

Maybe<number>

Example

Num.max([1, 5, 3]); // Some(5)
Num.max([]);        // None

mean

mean: (ns) => Maybe<number>

Computes the mean of a list of numbers. Returns None if the list is empty.

Parameters

ns

readonly number[]

Returns

Maybe<number>

Example

Num.mean([1, 2, 3]); // Some(2)
Num.mean([]);        // None

min

min: (ns) => Maybe<number>

Computes the minimum of a list of numbers. Returns None if the list is empty.

Parameters

ns

readonly number[]

Returns

Maybe<number>

Example

Num.min([5, 1, 3]); // Some(1)
Num.min([]);        // None

multiply

multiply: (b) => (a) => number

Multiplies a number by b. Data-last: use in pipe or Arr.map.

Parameters

b

number

Returns

(a) => number

Example

pipe(6, Num.multiply(7));                    // 42
pipe([1, 2, 3], Arr.map(Num.multiply(100))); // [100, 200, 300]

negate

negate: (n) => number

Negates a number (arithmetic negation).

Parameters

n

number

Returns

number

Example

pipe(5, Num.negate);  // -5
pipe(-5, Num.negate); // 5

parse

parse: (s) => Maybe<number>

Parses a string as a number. Returns None when the result is NaN.

Parameters

s

string

Returns

Maybe<number>

Example

Num.parse("42");   // Some(42)
Num.parse("3.14"); // Some(3.14)
Num.parse("abc");  // None
Num.parse("");     // None

range

range: (from, to, step) => readonly number[]

Generates an array of numbers from from to to (both inclusive), stepping by step (default 1). If step is negative or zero, or from > to, returns an empty array. When step does not land exactly on to, the last value is the largest reachable value that does not exceed to.

Parameters

from

number

to

number

step?

number = 1

Returns

readonly number[]

Example

Num.range(0, 5);       // [0, 1, 2, 3, 4, 5]
Num.range(0, 10, 2);   // [0, 2, 4, 6, 8, 10]
Num.range(0, 9, 2);    // [0, 2, 4, 6, 8]
Num.range(5, 0);       // []
Num.range(3, 3);       // [3]

remainder

remainder: (divisor) => (n) => Maybe<number>

Returns the remainder of dividing a number by divisor. Returns None when divisor is zero. Data-last: remainder(divisor)(a) = a % divisor.

Parameters

divisor

number

Returns

(n) => Maybe<number>

Example

pipe(10, Num.remainder(3));                           // Some(1)
pipe(5, Num.remainder(0));                            // None
pipe([10, 11, 12], Arr.filterMap(Num.remainder(3))); // [1, 2, 0]

round

round: (n) => number

Rounds a number to the nearest integer.

Parameters

n

number

Returns

number

Example

pipe(3.5, Num.round); // 4
pipe(3.4, Num.round); // 3

subtract

subtract: (b) => (a) => number

Subtracts b from a number. Data-last: subtract(b)(a) = a - b.

Parameters

b

number

Returns

(a) => number

Example

pipe(10, Num.subtract(3));                  // 7
pipe([5, 10, 15], Arr.map(Num.subtract(2))); // [3, 8, 13]

sum

sum: (ns) => number = sumFn

Computes the sum of a list of numbers. Returns 0 if the list is empty.

Parameters

ns

readonly number[]

Returns

number

Example

Num.sum([1, 2, 3]); // 6
Num.sum([]);        // 0