@oazmi/superbuild 0.1.0

package/esm/deps/jsr.io/@oazmi/kitchensink/0.10.0/src/numericarray.js

@@ -0,0 +1,363 @@
+/** utility functions for numeric array manipulation and array math functions.
+ *
+ * @module
+*/
+import { resolveRange } from "./array1d.js";
+import { constructorOf } from "./struct.js";
+/** transpose a 2d array (matrix).
+ *
+ * if you're wondering what's the difference between this and {@link transposeArray2D} from the {@link "array2d"} submodule,
+ * then be my guest, because I am just as puzzled as you.
+ * perhaps I forgot that I made one or the other, resulting in duplication.
+ *
+ * however, there are a few implementation differences between the these two functions:
+ * - {@link transpose2D} works by calling the array `map` method.
+ * - {@link transposeArray2D} works by assigning values to the new array's transposed indexes.
+ *
+ * similarities between the two functions:
+ * - both transpose sparse 2d arrays to full 2d arrays with the sparse entries replaced with `undefined`.
+ * - both use the first element (the first row) to determine the number of columns your 2d array has.
+ *   this can mean disastrous cropped results if a sparse 2d array is provided where the first row's
+ *   number of elements (i.e. number of columns) is not the greatest out of all the other rows.
+ *
+ * @example
+ * ```ts
+ * import { assertEquals } from "jsr:@std/assert"
+ *
+ * const sparse_arr2d: Array<number[]> = [
+ * 	[1 , 2 , 3 , 4 , 5 ],
+ * 	[6 , 7 , 8 , 9],
+ * 	[11, 12, 13],
+ * 	[16, 17, 18, 19, 20],
+ * ]
+ *
+ * const sparse_arr2d_transposed = transpose2D(sparse_arr2d)
+ *
+ * sparse_arr2d_transposed satisfies Array<number>[]
+ *
+ * assertEquals(sparse_arr2d_transposed, [
+ * 	[1 , 6         , 11        , 16],
+ * 	[2 , 7         , 12        , 17],
+ * 	[3 , 8         , 13        , 18],
+ * 	[4 , 9         , undefined , 19],
+ * 	[5 , undefined , undefined , 20],
+ * ])
+ * ```
+*/
+export const transpose2D = (matrix) => (matrix[0].map((_row_0_col_i, i) => matrix.map(row_arr => row_arr[i])));
+/** compute the left-to-right running difference between successive elements.
+ *
+ * the returned array's length is decremented by one.
+ * as a result, a single element array will turn into an empty array.
+ *
+ * > [!note]
+ * > be careful when using with unsigned typed arrays.
+ *
+ * @example
+ * ```ts
+ * import { assertEquals } from "jsr:@std/assert"
+ *
+ * // basic example
+ * const arr1 = [1, 2, 3, 4, 5, 99, 88]
+ * const arr1_diff = diff(arr1)
+ * assertEquals(arr1_diff, [1, 1, 1, 1, 94, -11])
+ *
+ * // subarray slicing example
+ * const arr2 = [1, 2, 3, 4, 5, 99, 88]
+ * const arr2_diff = diff(arr2, 2, -1)
+ * assertEquals(arr2_diff, [1, 1, 94])
+ * ```
+*/
+export const diff = (arr, start, end) => {
+    [start, end] = resolveRange(start, end, arr.length);
+    const diff_arr = arr.slice(start + 1, end);
+    for (let i = 0; i < diff_arr.length; i++) {
+        diff_arr[i] -= arr[start + i];
+    }
+    return diff_arr;
+};
+/** compute the right-to-left (ie reverse) running difference between preceding elements.
+ *
+ * the returned array's length is decremented by one.
+ * as a result, a single element array will turn into an empty array.
+ *
+ * > [!note]
+ * > be careful when using with unsigned typed arrays.
+ *
+ * @example
+ * ```ts
+ * import { assertEquals } from "jsr:@std/assert"
+ *
+ * // basic example
+ * const arr1 = [1, 2, 3, 4, 5, 99, 88]
+ * const arr1_diff = diff_right(arr1)
+ * assertEquals(arr1_diff, [-1, -1, -1, -1, -94, 11])
+ *
+ * // subarray slicing example
+ * const arr2 = [1, 2, 3, 4, 5, 99, 88]
+ * const arr2_diff = diff_right(arr2, 2, -1)
+ * assertEquals(arr2_diff, [-1, -1, -94])
+ * ```
+*/
+export const diff_right = (arr, start, end) => {
+    [start, end] = resolveRange(start, end, arr.length);
+    const diff_arr = arr.slice(start, end - 1);
+    for (let i = 0; i < diff_arr.length; i++) {
+        diff_arr[i] -= arr[start + i + 1];
+    }
+    return diff_arr;
+};
+/** cumulative summation of an array.
+ *
+ * the returned array has its length increased by one.
+ *
+ * @example
+ * ```ts
+ * import { assertEquals } from "jsr:@std/assert"
+ *
+ * // basic example
+ * const arr1 = [10, 20, 30, 40, 50]
+ * const arr1_cum_sum = cumulativeSum(arr1)
+ * assertEquals(arr1_cum_sum, [0, 10, 30, 60, 100, 150])
+ * ```
+*/
+export const cumulativeSum = (arr) => {
+    const len = arr.length, cum_sum = new (constructorOf(arr))(len + 1).fill(0);
+    for (let i = 0; i < len; i++) {
+        cum_sum[i + 1] = cum_sum[i] + arr[i];
+    }
+    return cum_sum;
+};
+/** conduct in-place unary arithmetic operations on numeric arrays
+ * TODO: find out why I'm not exporting this function. did I simply forget?
+ * @category inplace
+*/
+const unaryArithmetic = (operation, arr, start, end) => {
+    const [xs, xe] = resolveRange(start, end, arr.length);
+    switch (operation) {
+        case "abs": return abs(arr, xs, xe);
+        case "neg": return neg(arr, xs, xe);
+        case "comp": return bcomp(arr, xs, xe);
+    }
+};
+/** conduct in-place scalar arithmetic operations on numeric arrays
+ * TODO: find out why I'm not exporting this function. did I simply forget?
+ * @category inplace
+*/
+const scalarArithmetic = (operation, arr, value, start, end) => {
+    const [xs, xe] = resolveRange(start, end, arr.length);
+    switch (operation) {
+        case "add": return add(arr, value, xs, xe);
+        case "sub": return sub(arr, value, xs, xe);
+        case "mult": return mult(arr, value, xs, xe);
+        case "div": return div(arr, value, xs, xe);
+        case "pow": return pow(arr, value, xs, xe);
+        case "rem": return rem(arr, value, xs, xe);
+        case "mod": return mod(arr, value, xs, xe);
+        case "and": return band(arr, value, xs, xe);
+        case "or": return bor(arr, value, xs, xe);
+        case "xor": return bxor(arr, value, xs, xe);
+        case "<<": return blsh(arr, value, xs, xe);
+        case ">>": return brsh(arr, value, xs, xe);
+        case ">>>": return bursh(arr, value, xs, xe);
+    }
+};
+/// UNARY OPERATIONS
+/** mutate array in-place to get **absolute** value of elements.
+ *
+ * @category unaryOperator
+ * @category inplace
+ */
+export const abs = (arr, start = 0, end) => {
+    [start, end] = resolveRange(start, end, arr.length);
+    for (let i = start; i < end; i++) {
+        arr[i] *= arr[i] < 0 ? -1 : 1;
+    }
+    return arr;
+};
+/** mutate array in-place to get **negative** value of elements.
+ *
+ * @category unaryOperator
+ * @category inplace
+ */
+export const neg = (arr, start = 0, end) => {
+    [start, end] = resolveRange(start, end, arr.length);
+    for (let i = start; i < end; i++) {
+        arr[i] *= -1;
+    }
+    return arr;
+};
+/** mutate array in-place to get **bitwise complement** value of elements.
+ *
+ * @category unaryOperator
+ * @category inplace
+*/
+export const bcomp = (arr, start, end) => {
+    [start, end] = resolveRange(start, end, arr.length);
+    for (let i = start; i < end; i++) {
+        arr[i] = ~arr[i];
+    }
+    return arr;
+};
+/// SCALAR OPERATIONS
+/// TODO consider replacing some functions entirely with a linear function `y = ax + b`.
+/** mutate array in-place to get **bitwise and** against a scalar `value`.
+ *
+ * @category scalarOperator
+ * @category inplace
+*/
+export const band = (arr, value, start, end) => {
+    [start, end] = resolveRange(start, end, arr.length);
+    for (let i = start; i < end; i++) {
+        arr[i] &= value;
+    }
+    return arr;
+};
+/** mutate array in-place to get **bitwise or** against a scalar `value`.
+ *
+ * @category scalarOperator
+ * @category inplace
+*/
+export const bor = (arr, value, start, end) => {
+    [start, end] = resolveRange(start, end, arr.length);
+    for (let i = start; i < end; i++) {
+        arr[i] |= value;
+    }
+    return arr;
+};
+/** mutate array in-place to get **bitwise xor** against a scalar `value`.
+ *
+ * @category scalarOperator
+ * @category inplace
+*/
+export const bxor = (arr, value, start, end) => {
+    [start, end] = resolveRange(start, end, arr.length);
+    for (let i = start; i < end; i++) {
+        arr[i] ^= value;
+    }
+    return arr;
+};
+/** mutate array in-place to get **bitwise left-shift** (`<<`) against a scalar `value`.
+ *
+ * @category scalarOperator
+ * @category inplace
+*/
+export const blsh = (arr, value, start, end) => {
+    [start, end] = resolveRange(start, end, arr.length);
+    for (let i = start; i < end; i++) {
+        arr[i] <<= value;
+    }
+    return arr;
+};
+/** mutate array in-place to get **bitwise right-shift** (`>>`) against a scalar `value`.
+ *
+ * @category scalarOperator
+ * @category inplace
+*/
+export const brsh = (arr, value, start, end) => {
+    [start, end] = resolveRange(start, end, arr.length);
+    for (let i = start; i < end; i++) {
+        arr[i] >>= value;
+    }
+    return arr;
+};
+/** mutate array in-place to get **bitwise unsigned right-shift** (`>>>`) against a scalar `value`.
+ *
+ * @category scalarOperator
+ * @category inplace
+*/
+export const bursh = (arr, value, start, end) => {
+    [start, end] = resolveRange(start, end, arr.length);
+    for (let i = start; i < end; i++) {
+        arr[i] >>>= value;
+    }
+    return arr;
+};
+/** mutate array in-place to **add** a scalar `value`.
+ *
+ * @category scalarOperator
+ * @category inplace
+*/
+export const add = (arr, value, start, end) => {
+    [start, end] = resolveRange(start, end, arr.length);
+    for (let i = start; i < end; i++) {
+        arr[i] += value;
+    }
+    return arr;
+};
+/** mutate array in-place to **subtract** a scalar `value`.
+ *
+ * @category scalarOperator
+ * @category inplace
+*/
+export const sub = (arr, value, start, end) => {
+    [start, end] = resolveRange(start, end, arr.length);
+    for (let i = start; i < end; i++) {
+        arr[i] -= value;
+    }
+    return arr;
+};
+/** mutate array in-place to **multiply** by a scalar `value`.
+ *
+ * @category scalarOperator
+ * @category inplace
+*/
+export const mult = (arr, value, start, end) => {
+    [start, end] = resolveRange(start, end, arr.length);
+    for (let i = start; i < end; i++) {
+        arr[i] *= value;
+    }
+    return arr;
+};
+/** mutate array in-place to **divide** by a scalar `value`.
+ *
+ * @category scalarOperator
+ * @category inplace
+*/
+export const div = (arr, value, start, end) => {
+    [start, end] = resolveRange(start, end, arr.length);
+    for (let i = start; i < end; i++) {
+        arr[i] /= value;
+    }
+    return arr;
+};
+/** mutate array in-place to raise it to the **power** of a scalar `value`.
+ *
+ * @category scalarOperator
+ * @category inplace
+*/
+export const pow = (arr, value, start, end) => {
+    [start, end] = resolveRange(start, end, arr.length);
+    for (let i = start; i < end; i++) {
+        arr[i] **= value;
+    }
+    return arr;
+};
+/** mutate array in-place to get the **remainder** (`%`) when divided by scalar `value`.
+ *
+ * note that this is slightly different from the modulo {@link mod} operator, as this can have a negative sign.
+ *
+ * @category scalarOperator
+ * @category inplace
+*/
+export const rem = (arr, value, start, end) => {
+    [start, end] = resolveRange(start, end, arr.length);
+    for (let i = start; i < end; i++) {
+        arr[i] %= value;
+    }
+    return arr;
+};
+/** mutate array in-place to get the **modulo** when divided by scalar `value`.
+ *
+ * note that this is slightly different from the remainder {@link rem} operator, as this always returns a positive number.
+ *
+ * @category scalarOperator
+ * @category inplace
+*/
+export const mod = (arr, value, start, end) => {
+    [start, end] = resolveRange(start, end, arr.length);
+    for (let i = start; i < end; i++) {
+        arr[i] = ((arr[i] % value) + value) % value;
+    }
+    return arr;
+};

package/esm/deps/jsr.io/@oazmi/kitchensink/0.10.0/src/numericmethods.d.ts

@@ -0,0 +1,233 @@
+/** utility functions for common number manipulation functions.
+ *
+ * these functions go nicely with the {@link "mapper"} and {@link "lambdacalc"} submodules.
+ *
+ * @module
+*/
+import type { UnitInterval } from "./typedefs.js";
+/** clamp a `number` to inclusive `min` and `max` intervals.
+ *
+ * you can also provide a type alias for the output interval `OutInterval` number through the use of the generic parameter.
+ *
+ * @param value value to clamp
+ * @param min inclusive minimum of the interval
+ * @param max inclusive maximum of the interval
+ *
+ * @example
+ * ```ts
+ * import { assertEquals } from "jsr:@std/assert"
+ *
+ * assertEquals(clamp(-5, -1, 10), -1)
+ * assertEquals(clamp(5, -1, 10),  5)
+ * assertEquals(clamp(15, -1, 10), 10)
+ * ```
+*/
+export declare const clamp: <OutInterval extends number = number>(value: number, min?: OutInterval, max?: OutInterval) => OutInterval;
+/** get the mathematical modulo: `value` **mod** `mod`.
+ *
+ * **modulo** is different from javascript's `%` **remainder** operator in that the **modulo** operation always returns a positive number.
+ *
+ * @example
+ * ```ts
+ * import { assertEquals } from "jsr:@std/assert"
+ *
+ * assertEquals(modulo( 5, 3), 2)
+ * assertEquals(modulo(-5, 3), 1)
+ * assertEquals(modulo(-4, 3), 2)
+ * assertEquals(modulo(-3, 3), 0)
+ * assertEquals( 5 % 3,  2)
+ * assertEquals(-5 % 3, -2)
+ * assertEquals(-4 % 3, -1)
+ * assertEquals(-3 % 3, -0)
+ * ```
+*/
+export declare const modulo: (value: number, mod: number) => number;
+/** get the linearly interpolated value between two scalar points `x0` and `x1`, decided by unit interval time `t`.
+ *
+ * in other words:
+ * - `lerp(x0, x1, 0.0) === x0`
+ * - `lerp(x0, x1, 1.0) === x1`
+ * - `x0 < lerp(x0, x1, t > 0.0 && t < 1.0) < x1`
+ *
+ * > [!note]
+ * > this lerp function does not clamp the time parameter `t` to the closed {@link UnitInterval} `[0.0, 1.0]`.
+ * > to ensure clamping of `t` to the unit interval, use the {@link lerpClamped} function.
+ *
+ * @example
+ * ```ts
+ * import { assertEquals } from "jsr:@std/assert"
+ *
+ * assertEquals(lerp( 0, 100,  0.5),  50)
+ * assertEquals(lerp(50, 100,  0.5),  75)
+ * assertEquals(lerp(50, 100,  0.0),  50)
+ * assertEquals(lerp(50, 100,  1.0), 100)
+ * assertEquals(lerp(50, 100,  1.5), 125)
+ * assertEquals(lerp(50, 100, -0.5),  25)
+ * assertEquals(lerp(50, 100, -1.0),   0)
+ * assertEquals(lerp(50, 100, -2.5), -75)
+ * ```
+*/
+export declare const lerp: (x0: number, x1: number, t: UnitInterval) => number;
+/** same as {@link lerp}, except the time `t` is Clamped to the closed {@link UnitInterval} `[0.0, 1.0]`. */
+export declare const lerpClamped: (x0: number, x1: number, t: UnitInterval) => number;
+/** get the {@link lerp} interpolation of the `i`th dimension of two array vector points `v0` and `v1`, at time `t`.
+ *
+ * @example
+ * ```ts
+ * import { assertEquals } from "jsr:@std/assert"
+ *
+ * assertEquals(lerpi([ 0, 40], [100, 80],  0.5, 0),  50)
+ * assertEquals(lerpi([ 0, 40], [100, 80],  0.5, 1),  60)
+ * assertEquals(lerpi([50, 40], [100, 80],  0.5, 0),  75)
+ * assertEquals(lerpi([50, 40], [100, 80],  0.0, 0),  50)
+ * assertEquals(lerpi([50, 40], [100, 80],  1.0, 0), 100)
+ * assertEquals(lerpi([50, 40], [100, 80],  1.5, 0), 125)
+ * assertEquals(lerpi([50, 40], [100, 80], -0.5, 0),  25)
+ * assertEquals(lerpi([50, 40], [100, 80], -1.0, 0),   0)
+ * assertEquals(lerpi([50, 40], [100, 80], -2.5, 0), -75)
+ * ```
+*/
+export declare const lerpi: <Vec extends number[] = number[]>(v0: Vec, v1: Vec, t: UnitInterval, i: number) => number;
+/** get the {@link lerpClamped} interpolation of the `i`th dimension of two array vector points `v0` and `v1`, at time `t`. */
+export declare const lerpiClamped: <Vec extends number[] = number[]>(v0: Vec, v1: Vec, t: UnitInterval, i: number) => number;
+/** get the {@link lerp} interpolation vector between two array vector points `v0` and `v1`, at time `t`.
+ *
+ * @example
+ * ```ts
+ * import { assertEquals } from "jsr:@std/assert"
+ *
+ * assertEquals(lerpv([ 0, 40], [100, 80],  0.5), [ 50,  60])
+ * assertEquals(lerpv([50,  0], [100, 80],  0.5), [ 75,  40])
+ * assertEquals(lerpv([50, 40], [100, 80],  0.0), [ 50,  40])
+ * assertEquals(lerpv([50, 40], [100, 80],  1.0), [100,  80])
+ * assertEquals(lerpv([50, 40], [100, 80],  1.5), [125, 100])
+ * assertEquals(lerpv([50, 40], [100, 80], -0.5), [ 25,  20])
+ * assertEquals(lerpv([50, 40], [100, 80], -1.0), [  0,   0])
+ * assertEquals(lerpv([50, 40], [100, 80], -2.5), [-75, -60])
+ * assertEquals(lerpv(
+ * 	[   0,  10, 100, 1000],
+ * 	[1000, 100,  10,    0],
+ * 	0.25,
+ * ), [250, 32.5, 77.5, 750])
+ * ```
+*/
+export declare const lerpv: <Vec extends number[] = number[]>(v0: Vec, v1: Vec, t: UnitInterval) => Vec;
+/** get the {@link lerpClamped} interpolation vector between two array vector points `v0` and `v1`, at time `t`. */
+export declare const lerpvClamped: <Vec extends number[] = number[]>(v0: Vec, v1: Vec, t: UnitInterval) => Vec;
+/** get the inverse of the interpolation {@link lerp}`(x0, x1, t)`, which is to say:
+ * find the {@link UnitInterval} parameter `t`, given a scalar number `x` in the closed interval `[x0, x1]`.
+ *
+ * @example
+ * ```ts
+ * import { assertEquals } from "jsr:@std/assert"
+ *
+ * assertEquals(invlerp( 0, 100,   50),  0.5)
+ * assertEquals(invlerp(50, 100,   75),  0.5)
+ * assertEquals(invlerp(50, 100,   50),  0.0)
+ * assertEquals(invlerp(50, 100,  100),  1.0)
+ * assertEquals(invlerp(50, 100,  125),  1.5)
+ * assertEquals(invlerp(50, 100,   25), -0.5)
+ * assertEquals(invlerp(50, 100,    0), -1.0)
+ * assertEquals(invlerp(50, 100,  -75), -2.5)
+ * ```
+*/
+export declare const invlerp: (x0: number, x1: number, x: number) => UnitInterval;
+/** same as {@link invlerp}, except that we force clamp the output {@link UnitInterval} `t` to the closed interval `[0, 1]`. */
+export declare const invlerpClamped: (x0: number, x1: number, x: number) => UnitInterval;
+/** get the {@link invlerp} (inverse interpolation) of the `i`th dimension of two vector point intervals `v0` and `v1`, at vector position `v`. */
+export declare const invlerpi: <Vec extends number[] = number[]>(v0: Vec, v1: Vec, v: Vec, i: number) => UnitInterval;
+/** get the {@link invlerpClamped} of the `i`th dimension of two array vector point intervals `v0` and `v1`, at vector position `v`. */
+export declare const invlerpiClamped: <Vec extends number[] = number[]>(v0: Vec, v1: Vec, v: Vec, i: number) => UnitInterval;
+/** `limp` is a made up abbreviation for _linear interval map_, which linearly maps:
+ * - a scalar value `x0`, that's in a
+ * - scalar interval `u0: [min: number, max: number]` to
+ * - a scalar output return value `x1`, that's in the
+ * - scalar interval `u1: [min: number, max: number]`
+ *
+ * the math equation is simply `x1 = u1[0] + (x - u0[0]) * (u1[1] - u1[0]) / (u0[1] - u0[0])`.
+ * which is basically doing inverse_lerp on `x0` to find `t`, then applying lerp onto interval `u1` with the found `t`.
+ *
+ * you may think of this function as a means for finding the "y-coordinate" (`x1`) of a point at the "x-coordinate" `x0`,
+ * that is between two connected line segment points `(u0[0], u1[0])` and `(u0[1], u1[1])`.
+*/
+export declare const limp: (u0: [min: number, max: number], u1: [min: number, max: number], x0: number) => number;
+/** same as {@link limp}, except the output `x1` is force clamped to the interval `u1`. */
+export declare const limpClamped: (u0: [min: number, max: number], u1: [min: number, max: number], x0: number) => number;
+/** sum up an array of numbers.
+ *
+ * @example
+ * ```ts
+ * import { assertEquals } from "jsr:@std/assert"
+ *
+ * assertEquals(sum([0, 1, 2, 3, 4]),  10)
+ * assertEquals(sum([-11, 7, 5, -8]),  -7)
+ * ```
+*/
+export declare const sum: (values: number[]) => number;
+/** get the minimum between two numbers.
+ *
+ * this function is faster than `Math.min` as it uses the ternary conditional operator, which makes it highly JIT optimized.
+*/
+export declare const min: (v0: number, v1: number) => number;
+/** get the maximum between two numbers.
+ *
+ * this function is faster than `Math.max` as it uses the ternary conditional operator, which makes it highly JIT optimized.
+*/
+export declare const max: (v0: number, v1: number) => number;
+/** get the sign of a number. you'll get a `1` for positive numbers (or zero), and `-1` otherwise.
+ *
+ * this function is faster than `Math.sign` as it uses the ternary conditional operator, which makes it highly JIT optimized.
+*/
+export declare const sign: (value: number) => (1 | -1);
+/** get the absolute positive value of a number.
+ *
+ * this function is faster than `Math.abs` as it uses the ternary conditional operator, which makes it highly JIT optimized.
+ *
+ * the reason why we don't call this function `abs` is because one such function already exists in the numericarray submodule ({@link abs}).
+*/
+export declare const absolute: (value: number) => number;
+/** round a float number to a certain precision, so that floating floating-point arithmetic inaccuracies can be nullified.
+ *
+ * the way it works is by multiplying the initial `value` by a large number, so that it is at least a whole number,
+ * and then we round it to the closest integer value with `Math.round`,
+ * and finally we follow it up with a division by the very same old large number.
+ *
+ * @param value the floating number to round.
+ * @param precision an integer dictating the number of decimal points to which the `value` should be rounded to.
+ *   you may use negative integer for rounding to `10s`, `100s`, etc..., or use a value of `0` for rounding to nearest integer.
+ *   also, you would want to the `precision` to be less than the number of decimal digits representable by your js-runtime's floating-point.
+ *   so for 64-bit runtime (double), the max precision limit is `15`, and for a 32-bit runtime (single), the limit is `7`.
+ *   picking a precision that is higher than your runtime's limit will result in even worse value rounding than your original `value`.
+ *   defaults to `9` (i.e. rounds to closest nano-number (10**(-9))).
+ * @returns the float number rounded to the given precision.
+ *
+ * @examples
+ * ```ts
+ * import { assert } from "jsr:@std/assert"
+ *
+ * // aliasing our function for brevity
+ * const fn = roundFloat
+ *
+ * // notice that due to floating inaccuracy `0.2 + 0.4` equals to `0.6000000000000001` instead of `0.6`
+ * assert((0.2 + 0.4) !== 0.6)
+ * assert((0.2 + 0.4) === 0.6000000000000001)
+ *
+ * // so, it is often desirable to round the resulting number to some precision to negate this slight deviation.
+ * assert(fn(0.2 + 0.4) === 0.6)
+ *
+ * // you can also provide a custom precision with the second parameter
+ * assert(fn(123.456789,  2) === 123.46) // rounding to  2 decimal places
+ * assert(fn(123.456789,  1) === 123.5)  // rounding to  1 decimal places
+ * assert(fn(123.456789,  0) === 123)    // rounding to  0 decimal places (i.e. closest integer)
+ * assert(fn(123.456789, -1) === 120)    // rounding to -1 decimal places (i.e. closest 10s)
+ * assert(fn(123.456789, -2) === 100)    // rounding to -2 decimal places (i.e. closest 100s)
+ *
+ * // other examples:
+ * assert(  (0.2 - 0.7) === -0.49999999999999994)
+ * assert(fn(0.2 - 0.7) === -0.5)
+ * assert(  (0.2 * 3.0) === 0.6000000000000001)
+ * assert(fn(0.2 * 3.0) === 0.6)
+ * ```
+*/
+export declare const roundFloat: (value: number, precision?: number) => number;
+//# sourceMappingURL=numericmethods.d.ts.map

package/esm/deps/jsr.io/@oazmi/kitchensink/0.10.0/src/numericmethods.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"numericmethods.d.ts","sourceRoot":"","sources":["../../../../../../../src/deps/jsr.io/@oazmi/kitchensink/0.10.0/src/numericmethods.ts"],"names":[],"mappings":"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"}