effect 4.0.0-beta.70 → 4.0.0-beta.72

package/dist/BigInt.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"BigInt.d.ts","sourceRoot":"","sources":["../src/BigInt.ts"],"names":[],"mappings":"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"}
+{"version":3,"file":"BigInt.d.ts","sourceRoot":"","sources":["../src/BigInt.ts"],"names":[],"mappings":"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"}

package/dist/BigInt.js

@@ -1,6 +1,69 @@
 /**
- * This module provides utility functions and type class instances for working with the `bigint` type in TypeScript.
- * It includes functions for basic arithmetic operations.
+ * Tools for working with JavaScript `bigint` values in Effect code. The module
+ * includes arithmetic, comparisons, range checks, safe conversions, integer
+ * square roots, aggregation helpers, and `Order`, `Equivalence`, `Reducer`, and
+ * `Combiner` instances for APIs that consume those abstractions.
+ *
+ * Reach for `BigInt` when values may exceed JavaScript's safe `number` integer
+ * range, when conversions should make failure explicit with `Option`, or when
+ * Effect collection APIs need bigint-specific ordering or combining behavior.
+ *
+ * **Mental model**
+ *
+ * - Values are native JavaScript `bigint`s; the module does not introduce a
+ *   wrapper type.
+ * - Binary operations such as {@link sum}, {@link multiply}, {@link subtract},
+ *   {@link divide}, {@link min}, and {@link max} are dual and work in
+ *   data-first or data-last style.
+ * - Safe operations return `Option`, including {@link divide}, {@link sqrt},
+ *   {@link fromString}, {@link fromNumber}, and {@link toNumber}.
+ * - Unsafe or native operations keep JavaScript behavior, including thrown
+ *   errors from {@link BigInt}, {@link divideUnsafe}, {@link sqrtUnsafe}, and
+ *   {@link remainder} for invalid inputs.
+ *
+ * **Common tasks**
+ *
+ * - Check and construct values: {@link isBigInt}, {@link BigInt},
+ *   {@link fromString}, {@link fromNumber}, {@link toNumber}
+ * - Do arithmetic: {@link sum}, {@link multiply}, {@link subtract},
+ *   {@link divide}, {@link divideUnsafe}, {@link remainder}, {@link increment},
+ *   {@link decrement}
+ * - Compare and bound values: {@link Order}, {@link Equivalence},
+ *   {@link isLessThan}, {@link isLessThanOrEqualTo}, {@link isGreaterThan},
+ *   {@link isGreaterThanOrEqualTo}, {@link between}, {@link clamp},
+ *   {@link min}, {@link max}
+ * - Work with signs and number theory: {@link sign}, {@link abs}, {@link gcd},
+ *   {@link lcm}, {@link sqrt}, {@link sqrtUnsafe}
+ * - Aggregate many values: {@link sumAll}, {@link multiplyAll},
+ *   {@link ReducerSum}, {@link ReducerMultiply}, {@link CombinerMax},
+ *   {@link CombinerMin}
+ *
+ * **Gotchas**
+ *
+ * - JavaScript does not allow mixing `number` and `bigint` in arithmetic. Use
+ *   {@link fromNumber} and {@link toNumber} when crossing that boundary.
+ * - JavaScript `bigint` division truncates toward zero, and {@link remainder}
+ *   follows JavaScript `%` semantics.
+ * - The native {@link BigInt} constructor follows JavaScript coercion rules and
+ *   may throw. Use {@link fromString} or {@link fromNumber} when failed
+ *   conversion should be represented as `Option.none()`.
+ *
+ * **Quickstart**
+ *
+ * **Example** (Safe arithmetic and conversion)
+ *
+ * ```ts
+ * import { BigInt } from "effect"
+ *
+ * const total = BigInt.sumAll([10n, 20n, 30n])
+ * const average = BigInt.divide(total, 3n)
+ * const bounded = BigInt.clamp(total, { minimum: 0n, maximum: 50n })
+ *
+ * console.log(total) // 60n
+ * console.log(average) // Option.some(20n)
+ * console.log(bounded) // 50n
+ * console.log(BigInt.fromString("not an integer")) // Option.none()
+ * ```
  *
  * @since 2.0.0
  */
@@ -12,7 +75,20 @@ import * as order from "./Order.js";
 import * as predicate from "./Predicate.js";
 import * as Reducer from "./Reducer.js";
 /**
- * Reference to the global BigInt constructor.
+ * Exposes the global bigint constructor for JavaScript bigint coercion.
+ *
+ * **When to use**
+ *
+ * Use to access native JavaScript bigint constructor coercion from the Effect
+ * module namespace.
+ *
+ * **Gotchas**
+ *
+ * This follows native `BigInt` coercion rules. It throws for invalid strings or
+ * non-integral numbers, and whitespace-only strings coerce to `0n`.
+ *
+ * @see {@link fromString} for parsing strings into an `Option`
+ * @see {@link fromNumber} for converting safe integers into an `Option`
  *
  * **Example** (Constructing bigints)
  *
@@ -34,7 +110,11 @@ const bigint0 = /*#__PURE__*/BigInt(0);
 const bigint1 = /*#__PURE__*/BigInt(1);
 const bigint2 = /*#__PURE__*/BigInt(2);
 /**
- * Tests if a value is a `bigint`.
+ * Checks whether a value is a `bigint`.
+ *
+ * **When to use**
+ *
+ * Use to validate unknown input and narrow it to `bigint`.
  *
  * **Example** (Checking for bigints)
  *
@@ -53,6 +133,10 @@ export const isBigInt = predicate.isBigInt;
 /**
  * Provides an addition operation on `bigint`s.
  *
+ * **When to use**
+ *
+ * Use to add two `bigint` values.
+ *
  * **Example** (Adding bigints)
  *
  * ```ts
@@ -62,6 +146,8 @@ export const isBigInt = predicate.isBigInt;
  * assert.deepStrictEqual(BigInt.sum(2n, 3n), 5n)
  * ```
  *
+ * @see {@link sumAll} for summing an iterable of `bigint` values
+ *
  * @category math
  * @since 2.0.0
  */
@@ -69,6 +155,10 @@ export const sum = /*#__PURE__*/dual(2, (self, that) => self + that);
 /**
  * Provides a multiplication operation on `bigint`s.
  *
+ * **When to use**
+ *
+ * Use to multiply two `bigint` values.
+ *
  * **Example** (Multiplying bigints)
  *
  * ```ts
@@ -78,6 +168,8 @@ export const sum = /*#__PURE__*/dual(2, (self, that) => self + that);
  * assert.deepStrictEqual(BigInt.multiply(2n, 3n), 6n)
  * ```
  *
+ * @see {@link multiplyAll} for multiplying an iterable of `bigint` values
+ *
  * @category math
  * @since 2.0.0
  */
@@ -85,6 +177,10 @@ export const multiply = /*#__PURE__*/dual(2, (self, that) => self * that);
 /**
  * Provides a subtraction operation on `bigint`s.
  *
+ * **When to use**
+ *
+ * Use to subtract one `bigint` value from another.
+ *
  * **Example** (Subtracting bigints)
  *
  * ```ts
@@ -99,7 +195,12 @@ export const multiply = /*#__PURE__*/dual(2, (self, that) => self * that);
  */
 export const subtract = /*#__PURE__*/dual(2, (self, that) => self - that);
 /**
- * Safely divides one `bigint` by another.
+ * Divides one `bigint` by another safely.
+ *
+ * **When to use**
+ *
+ * Use to divide `bigint` values while representing division by zero as
+ * `Option.none`.
  *
  * **Details**
  *
@@ -116,6 +217,9 @@ export const subtract = /*#__PURE__*/dual(2, (self, that) => self - that);
  * assert.deepStrictEqual(BigInt.divide(6n, 0n), Option.none())
  * ```
  *
+ * @see {@link divideUnsafe} for division that throws when the divisor is `0n`
+ * @see {@link remainder} for the JavaScript remainder operation
+ *
  * @category math
  * @since 2.0.0
  */
@@ -123,6 +227,11 @@ export const divide = /*#__PURE__*/dual(2, (self, that) => that === bigint0 ? Op
 /**
  * Divides one `bigint` by another, throwing if the divisor is zero.
  *
+ * **When to use**
+ *
+ * Use when the divisor is known to be non-zero and division by zero should be a
+ * thrown exception.
+ *
  * **Details**
  *
  * Uses JavaScript `bigint` division, so non-exact quotients are truncated
@@ -142,6 +251,8 @@ export const divide = /*#__PURE__*/dual(2, (self, that) => that === bigint0 ? Op
  * assert.deepStrictEqual(BigInt.divideUnsafe(6n, 4n), 1n)
  * ```
  *
+ * @see {@link divide} for division that returns `Option.none` when the divisor is `0n`
+ *
  * @category math
  * @since 4.0.0
  */
@@ -149,6 +260,10 @@ export const divideUnsafe = /*#__PURE__*/dual(2, (self, that) => self / that);
 /**
  * Returns the result of adding `1n` to a `bigint`.
  *
+ * **When to use**
+ *
+ * Use to increment a `bigint` counter by one.
+ *
  * **Example** (Incrementing a bigint)
  *
  * ```ts
@@ -165,6 +280,10 @@ export const increment = n => n + bigint1;
 /**
  * Returns the result of subtracting `1n` from a `bigint`.
  *
+ * **When to use**
+ *
+ * Use to decrement a `bigint` counter by one.
+ *
  * **Example** (Decrementing a bigint)
  *
  * ```ts
@@ -181,6 +300,11 @@ export const decrement = n => n - bigint1;
 /**
  * Provides an `Order` instance for `bigint` that allows comparing and sorting BigInt values.
  *
+ * **When to use**
+ *
+ * Use when sorting or comparing bigint values through APIs that accept an
+ * ordering instance.
+ *
  * **Example** (Comparing bigints with Order)
  *
  * ```ts
@@ -200,7 +324,12 @@ export const decrement = n => n - bigint1;
  */
 export const Order = order.BigInt;
 /**
- * An `Equivalence` instance for bigints using strict equality (`===`).
+ * Equivalence instance for bigints using strict equality (`===`).
+ *
+ * **When to use**
+ *
+ * Use when checking bigint equality through APIs that accept an equivalence
+ * relation.
  *
  * **Example** (Comparing bigints for equivalence)
  *
@@ -218,6 +347,10 @@ export const Equivalence = Equ.BigInt;
 /**
  * Returns `true` if the first argument is less than the second, otherwise `false`.
  *
+ * **When to use**
+ *
+ * Use to test whether one `bigint` is strictly less than another.
+ *
  * **Example** (Checking less-than comparisons)
  *
  * ```ts
@@ -236,6 +369,10 @@ export const isLessThan = /*#__PURE__*/order.isLessThan(Order);
 /**
  * Returns a function that checks if a given `bigint` is less than or equal to the provided one.
  *
+ * **When to use**
+ *
+ * Use to test whether one `bigint` is less than or equal to another.
+ *
  * **Example** (Checking less-than-or-equal comparisons)
  *
  * ```ts
@@ -254,6 +391,10 @@ export const isLessThanOrEqualTo = /*#__PURE__*/order.isLessThanOrEqualTo(Order)
 /**
  * Returns `true` if the first argument is greater than the second, otherwise `false`.
  *
+ * **When to use**
+ *
+ * Use to test whether one `bigint` is strictly greater than another.
+ *
  * **Example** (Checking greater-than comparisons)
  *
  * ```ts
@@ -272,6 +413,10 @@ export const isGreaterThan = /*#__PURE__*/order.isGreaterThan(Order);
 /**
  * Returns a function that checks if a given `bigint` is greater than or equal to the provided one.
  *
+ * **When to use**
+ *
+ * Use to test whether one `bigint` is greater than or equal to another.
+ *
  * **Example** (Checking greater-than-or-equal comparisons)
  *
  * ```ts
@@ -288,7 +433,11 @@ export const isGreaterThan = /*#__PURE__*/order.isGreaterThan(Order);
  */
 export const isGreaterThanOrEqualTo = /*#__PURE__*/order.isGreaterThanOrEqualTo(Order);
 /**
- * Checks if a `bigint` is between a `minimum` and `maximum` value (inclusive).
+ * Checks whether a `bigint` is between a `minimum` and `maximum` value (inclusive).
+ *
+ * **When to use**
+ *
+ * Use to test whether a `bigint` falls inside an inclusive range.
  *
  * **Example** (Checking whether a bigint is within bounds)
  *
@@ -303,6 +452,8 @@ export const isGreaterThanOrEqualTo = /*#__PURE__*/order.isGreaterThanOrEqualTo(
  * assert.deepStrictEqual(between(6n), false)
  * ```
  *
+ * @see {@link clamp} for forcing a `bigint` into an inclusive range
+ *
  * @category predicates
  * @since 2.0.0
  */
@@ -310,6 +461,10 @@ export const between = /*#__PURE__*/order.isBetween(Order);
 /**
  * Restricts the given `bigint` to be within the range specified by the `minimum` and `maximum` values.
  *
+ * **When to use**
+ *
+ * Use to force a `bigint` into an inclusive range.
+ *
  * **Details**
  *
  * - If the `bigint` is less than the `minimum` value, the function returns the `minimum` value.
@@ -329,6 +484,8 @@ export const between = /*#__PURE__*/order.isBetween(Order);
  * assert.equal(clamp(6n), 5n)
  * ```
  *
+ * @see {@link between} for checking whether a `bigint` is already inside a range
+ *
  * @category math
  * @since 2.0.0
  */
@@ -336,6 +493,10 @@ export const clamp = /*#__PURE__*/order.clamp(Order);
 /**
  * Returns the minimum between two `bigint`s.
  *
+ * **When to use**
+ *
+ * Use to select the smaller of two `bigint` values.
+ *
  * **Example** (Finding the minimum bigint)
  *
  * ```ts
@@ -345,6 +506,8 @@ export const clamp = /*#__PURE__*/order.clamp(Order);
  * assert.deepStrictEqual(BigInt.min(2n, 3n), 2n)
  * ```
  *
+ * @see {@link max} for selecting the larger value
+ *
  * @category math
  * @since 2.0.0
  */
@@ -352,6 +515,10 @@ export const min = /*#__PURE__*/order.min(Order);
 /**
  * Returns the maximum between two `bigint`s.
  *
+ * **When to use**
+ *
+ * Use to select the larger of two `bigint` values.
+ *
  * **Example** (Finding the maximum bigint)
  *
  * ```ts
@@ -361,6 +528,8 @@ export const min = /*#__PURE__*/order.min(Order);
  * assert.deepStrictEqual(BigInt.max(2n, 3n), 3n)
  * ```
  *
+ * @see {@link min} for selecting the smaller value
+ *
  * @category math
  * @since 2.0.0
  */
@@ -368,6 +537,10 @@ export const max = /*#__PURE__*/order.max(Order);
 /**
  * Determines the sign of a given `bigint`.
  *
+ * **When to use**
+ *
+ * Use to classify a `bigint` as negative, zero, or positive.
+ *
  * **Example** (Determining bigint signs)
  *
  * ```ts
@@ -386,6 +559,10 @@ export const sign = n => order.BigInt(n, bigint0);
 /**
  * Determines the absolute value of a given `bigint`.
  *
+ * **When to use**
+ *
+ * Use to remove the sign from a `bigint` while preserving its magnitude.
+ *
  * **Example** (Calculating absolute values)
  *
  * ```ts
@@ -404,6 +581,10 @@ export const abs = n => n < bigint0 ? -n : n;
 /**
  * Determines the greatest common divisor of two `bigint`s.
  *
+ * **When to use**
+ *
+ * Use to compute the greatest common divisor of two integer values.
+ *
  * **Example** (Calculating greatest common divisors)
  *
  * ```ts
@@ -415,6 +596,8 @@ export const abs = n => n < bigint0 ? -n : n;
  * assert.deepStrictEqual(BigInt.gcd(16n, 24n), 8n)
  * ```
  *
+ * @see {@link lcm} for computing the least common multiple
+ *
  * @category math
  * @since 2.0.0
  */
@@ -429,6 +612,10 @@ export const gcd = /*#__PURE__*/dual(2, (self, that) => {
 /**
  * Determines the least common multiple of two `bigint`s.
  *
+ * **When to use**
+ *
+ * Use to compute the least common multiple of two integer values.
+ *
  * **Example** (Calculating least common multiples)
  *
  * ```ts
@@ -440,6 +627,8 @@ export const gcd = /*#__PURE__*/dual(2, (self, that) => {
  * assert.deepStrictEqual(BigInt.lcm(16n, 24n), 48n)
  * ```
  *
+ * @see {@link gcd} for computing the greatest common divisor
+ *
  * @category math
  * @since 2.0.0
  */
@@ -447,6 +636,10 @@ export const lcm = /*#__PURE__*/dual(2, (self, that) => self * that / gcd(self,
 /**
  * Returns the integer square root of a non-negative `bigint`.
  *
+ * **When to use**
+ *
+ * Use when the input is known to be non-negative and invalid input should throw.
+ *
  * **Details**
  *
  * For non-perfect squares, returns the largest `bigint` whose square is less
@@ -467,6 +660,8 @@ export const lcm = /*#__PURE__*/dual(2, (self, that) => self * that / gcd(self,
  * assert.deepStrictEqual(BigInt.sqrtUnsafe(16n), 4n)
  * ```
  *
+ * @see {@link sqrt} for returning `Option.none` when the input is negative
+ *
  * @category math
  * @since 4.0.0
  */
@@ -484,7 +679,12 @@ export const sqrtUnsafe = n => {
   return x;
 };
 /**
- * Safely returns the integer square root of a `bigint`.
+ * Computes the integer square root of a `bigint` safely.
+ *
+ * **When to use**
+ *
+ * Use to compute an integer square root while representing negative input as
+ * `Option.none`.
  *
  * **Details**
  *
@@ -503,6 +703,8 @@ export const sqrtUnsafe = n => {
  * BigInt.sqrt(-1n) // Option.none()
  * ```
  *
+ * @see {@link sqrtUnsafe} for square root computation that throws on negative input
+ *
  * @category math
  * @since 2.0.0
  */
@@ -510,6 +712,10 @@ export const sqrt = n => isGreaterThanOrEqualTo(n, bigint0) ? Option.some(sqrtUn
 /**
  * Takes an `Iterable` of `bigint`s and returns their sum as a single `bigint`. Returns `0n` for an empty iterable.
  *
+ * **When to use**
+ *
+ * Use to sum all `bigint` values in an iterable.
+ *
  * **Example** (Summing iterable bigints)
  *
  * ```ts
@@ -519,6 +725,9 @@ export const sqrt = n => isGreaterThanOrEqualTo(n, bigint0) ? Option.some(sqrtUn
  * assert.deepStrictEqual(BigInt.sumAll([2n, 3n, 4n]), 9n)
  * ```
  *
+ * @see {@link sum} for adding two `bigint` values
+ * @see {@link ReducerSum} for summing through APIs that consume a `Reducer`
+ *
  * @category math
  * @since 2.0.0
  */
@@ -532,6 +741,10 @@ export const sumAll = collection => {
 /**
  * Takes an `Iterable` of `bigint`s and returns their product as a single `bigint`. Returns `1n` for an empty iterable.
  *
+ * **When to use**
+ *
+ * Use to multiply all `bigint` values in an iterable.
+ *
  * **Example** (Multiplying iterable bigints)
  *
  * ```ts
@@ -541,6 +754,9 @@ export const sumAll = collection => {
  * assert.deepStrictEqual(BigInt.multiplyAll([2n, 3n, 4n]), 24n)
  * ```
  *
+ * @see {@link multiply} for multiplying two `bigint` values
+ * @see {@link ReducerMultiply} for multiplying through APIs that consume a `Reducer`
+ *
  * @category math
  * @since 2.0.0
  */
@@ -555,7 +771,12 @@ export const multiplyAll = collection => {
   return out;
 };
 /**
- * Converts a `bigint` to a `number`.
+ * Converts a `bigint` to a `number` safely.
+ *
+ * **When to use**
+ *
+ * Use to convert a `bigint` to a JavaScript number only when it is a safe
+ * integer.
  *
  * **Details**
  *
@@ -572,6 +793,8 @@ export const multiplyAll = collection => {
  * BI.toNumber(BigInt(Number.MIN_SAFE_INTEGER) - 1n) // Option.none()
  * ```
  *
+ * @see {@link fromNumber} for converting a safe integer number to `bigint`
+ *
  * @category converting
  * @since 2.0.0
  */
@@ -582,7 +805,11 @@ export const toNumber = b => {
   return Option.some(Number(b));
 };
 /**
- * Converts a string to a `bigint`.
+ * Parses a string into a `bigint` safely.
+ *
+ * **When to use**
+ *
+ * Use to parse a string as a `bigint` without throwing on invalid input.
  *
  * **Details**
  *
@@ -599,6 +826,8 @@ export const toNumber = b => {
  * BigInt.fromString("a") // Option.none()
  * ```
  *
+ * @see {@link BigInt} for native constructor coercion that throws on invalid input
+ *
  * @category converting
  * @since 2.4.12
  */
@@ -612,6 +841,10 @@ export const fromString = s => {
 /**
  * Converts a number to a `bigint`.
  *
+ * **When to use**
+ *
+ * Use to convert a JavaScript number to `bigint` only when it is a safe integer.
+ *
  * **Details**
  *
  * If the number is outside the safe integer range for JavaScript
@@ -629,6 +862,9 @@ export const fromString = s => {
  * BigInt.fromNumber(Number.MIN_SAFE_INTEGER - 1) // Option.none()
  * ```
  *
+ * @see {@link toNumber} for converting `bigint` values back to safe integer numbers
+ * @see {@link BigInt} for native constructor coercion
+ *
  * @category converting
  * @since 2.4.12
  */
@@ -645,6 +881,10 @@ export function fromNumber(n) {
 /**
  * Returns the JavaScript remainder of dividing one `bigint` by another.
  *
+ * **When to use**
+ *
+ * Use to compute the JavaScript `%` remainder for two `bigint` values.
+ *
  * **Details**
  *
  * The result follows JavaScript `%` semantics, including the sign of the
@@ -664,19 +904,43 @@ export function fromNumber(n) {
  * BigInt.remainder(15n, 4n) // 3n
  * ```
  *
+ * @see {@link divide} for quotient calculation with division-by-zero represented as `Option.none`
+ *
  * @category math
  * @since 4.0.0
  */
 export const remainder = /*#__PURE__*/dual(2, (self, divisor) => self % divisor);
 /**
- * A `Reducer` for combining `bigint`s using addition.
+ * Reducer for combining `bigint`s using addition.
+ *
+ * **When to use**
+ *
+ * Use to sum many `bigint` values through APIs that consume a `Reducer`.
+ *
+ * **Details**
+ *
+ * The initial value is `0n`, so `combineAll([])` returns `0n`.
+ *
+ * @see {@link sumAll} for summing an iterable directly
+ * @see {@link ReducerMultiply} for multiplying `bigint` values
  *
  * @category math
  * @since 4.0.0
  */
 export const ReducerSum = /*#__PURE__*/Reducer.make((a, b) => a + b, bigint0);
 /**
- * A `Reducer` for combining `bigint`s using multiplication.
+ * Reducer for combining `bigint`s using multiplication.
+ *
+ * **When to use**
+ *
+ * Use to multiply many `bigint` values through APIs that consume a `Reducer`.
+ *
+ * **Details**
+ *
+ * The initial value is `1n`, so `combineAll([])` returns `1n`.
+ *
+ * @see {@link multiplyAll} for multiplying an iterable directly
+ * @see {@link ReducerSum} for summing `bigint` values
  *
  * @category math
  * @since 4.0.0
@@ -690,14 +954,28 @@ export const ReducerMultiply = /*#__PURE__*/Reducer.make((a, b) => a * b, bigint
   return acc;
 });
 /**
- * A `Combiner` that returns the maximum `bigint`.
+ * Combiner that returns the maximum `bigint`.
+ *
+ * **When to use**
+ *
+ * Use to keep the largest `bigint` when an API consumes a `Combiner`.
+ *
+ * @see {@link CombinerMin} for keeping the smallest `bigint`
+ * @see {@link max} for comparing two `bigint` values directly
  *
  * @category math
  * @since 4.0.0
  */
 export const CombinerMax = /*#__PURE__*/Combiner.max(Order);
 /**
- * A `Combiner` that returns the minimum `bigint`.
+ * Combiner that returns the minimum `bigint`.
+ *
+ * **When to use**
+ *
+ * Use to keep the smallest `bigint` through APIs that consume a `Combiner`.
+ *
+ * @see {@link CombinerMax} for keeping the largest `bigint`
+ * @see {@link min} for comparing two `bigint` values directly
  *
  * @category math
  * @since 4.0.0