type-plus 6.8.0 → 7.0.0

package/cjs/math/numeric_struct.d.ts

@@ -0,0 +1,1469 @@
+import type { Tail } from '../array/tail.js';
+import type { PadStart } from '../tuple/tuple_plus.pad_start.js';
+import type { Add as NumericAdd } from './add.js';
+import type { ToNegative } from './math_plus.to_negative.js';
+/**
+ * Internal numeric representation to perform math operations.
+ *
+ * NumericStruct: `[Type, DigitsStruct]`
+ * DigitsStruct: `[Sign, Digits, Exponent]`
+ *
+ * It is similar to the floating point representation with some minor differences.
+ *
+ * @template Type Type of the value, either `number` or `bigint`.
+ * It captures the original type of the value,
+ * so that at the end of the operation,
+ * the value can be adjusted accordingly.
+ *
+ * @template Sign Sign of the value, either `+` or `-`.
+ *
+ * @template Digits Digits of the value.
+ * It is a tuple of digits,
+ * where each digits can range from 0 to 9 during input,
+ * and range from -10 to 89 during operation.
+ * The max 89 comes from multiplication:
+ *
+ * ```
+ * 99 * 9
+ * => [[    9,  9], 0]
+ * *  [        [9], 0]
+ * => [[   81, 81], 0]
+ * => [[   89,  1], 0]
+ * => [[ 8, 9,  1], 0]
+ * ```
+ *
+ * While -10 comes from subtraction:
+ *
+ * ```
+ * 100 - 99 = 1
+ * => [[  1,  0,  0], 0]
+ * -  [[      9,  9], 0]
+ * => [[  1, -9, -9], 0]
+ * => [[  1,-10,  1], 0] // here, as in intermediate step
+ * => [[  0,  0,  1], 0]
+ * => [[1], 0]
+ * => 1
+ * ```
+ *
+ *
+ * Unlike floating point numbers, the digits length is not limited.
+ *
+ * @template Exponent Exponent is the negative exponent of the number.
+ *
+ * ```
+ * 1.23 = 123e^-2 = [[1, 2, 3], 2]
+ * 0.0123 = 123e^-4 = [[1, 2, 3], 4]
+ * ```
+ *
+ * There are 2 kinds of `NumericStruct`:
+ * - Normalized: The `NumericStruct` is clean and can be converted to/from `number` or `bigint`
+ * - Not normalized: The `DigitsStruct` within the `NumericStruct` is normalized,
+ *   but may need to convert between `number` and `bigint`.\
+ *   e.g. bigint + float => float (if possible), number + number => bigint (too big)
+ *
+ * During operations, the `DigitsStruct` can be not normalized,
+ * but each operation should always normalize the `DigitsStruct` before returning.
+ * Each operations assume the input `DigitsStruct` is normalized.
+ *
+ * All operations are performed in similar way:
+ *
+ * value -> NormalizedNumericStruct -> operation(NormalizedDigitsStruct) -> NormalizedNumericStruct -> Value
+ *
+ * This allows the operations to be composable.
+ * */
+export type NumericStruct = ['bigint' | 'number', DigitsStruct];
+export type TYPE = 0;
+export type DIGITS_STRUCT = 1;
+export declare namespace NumericStruct {
+    /**
+     * Creates a `NumericStruct` from number or bigint `N`.
+     */
+    type FromNumeric<N extends number | bigint, Fail = never> = N extends number ? number extends N ? Fail : ['number', DigitsStruct.FromNumber<N>] : N extends bigint ? bigint extends N ? Fail : ['bigint', DigitsStruct.FromBigint<N>] : never;
+    /**
+     * Converts a `NumericStruct` to a number or bigint.
+     *
+     * It includes the normalization of the `NumericStruct`.
+     */
+    type ToNumeric<M extends NumericStruct> = DigitsStruct.ToString<M[DIGITS_STRUCT]> extends infer S extends string ? M[TYPE] extends 'bigint' ? StringToBigint<S, StringToNumber<S, `The value '${S}' cannot be represented as bigint or number`>> : StringToNumber<S, StringToBigint<S, `The value '${S}' cannot be represented as bigint or number`>> : never;
+    type Add<A extends NumericStruct, B extends NumericStruct> = [
+        A[TYPE],
+        DigitsStruct.Add<A[DIGITS_STRUCT], B[DIGITS_STRUCT]>
+    ];
+    type Subtract<A extends NumericStruct, B extends NumericStruct> = [
+        A[TYPE],
+        DigitsStruct.Subtract<A[DIGITS_STRUCT], B[DIGITS_STRUCT]>
+    ];
+    type Multiply<A extends NumericStruct, B extends NumericStruct> = [
+        A[TYPE],
+        DigitsStruct.Multiply<A[DIGITS_STRUCT], B[DIGITS_STRUCT]>
+    ];
+}
+type StringToBigint<S extends string, Fail> = S extends `${infer N extends bigint}` ? N : Fail;
+export type StringToNumber<S extends string, Fail> = S extends `${infer N extends number}` ? number extends N ? Fail : N : Fail;
+export type DigitsStruct = [Sign: '+' | '-', Digits: number[], Exponent: number];
+export type SIGN = 0;
+export type DIGITS = 1;
+export type EXPONENT = 2;
+export declare namespace DigitsStruct {
+    /**
+     * Creates a `DigitsStruct` from number `N`.
+     *
+     * @template N Number to create `DigitsStruct` from.
+     */
+    export type FromNumber<N extends number> = `${N}` extends `-${infer R}` ? R extends `${infer W}.${infer F}` ? [DigitArray.FromString<W>, DigitArray.FromString<F>] extends [
+        infer WA extends number[],
+        infer FA extends number[]
+    ] ? ['-', DigitArray.TrimLeadingZeros<[...WA, ...FA]>, FA['length']] : never : ['-', DigitArray.FromString<R>, 0] : `${N}` extends `${infer W}.${infer F}` ? [DigitArray.FromString<W>, DigitArray.FromString<F>] extends [
+        infer WA extends number[],
+        infer FA extends number[]
+    ] ? ['+', DigitArray.TrimLeadingZeros<[...WA, ...FA]>, FA['length']] : never : ['+', DigitArray.FromString<`${N}`>, 0];
+    /**
+     * Creates a `DigitsStruct` from bigint `N`.
+     *
+     * @template N Number to create `DigitsStruct` from.
+     */
+    export type FromBigint<N extends bigint> = `${N}` extends `-${infer R}` ? ['-', DigitArray.FromString<R>, 0] : ['+', DigitArray.FromString<`${N}`>, 0];
+    /**
+     * Converts a `DigitsStruct` to string.
+     *
+     * @template D A normalized `DigitsStruct`.
+     */
+    export type ToString<D extends DigitsStruct> = (PadStart<D[DIGITS], D[EXPONENT], 0> extends infer Padded extends number[] ? Padded['length'] extends D[EXPONENT] ? DigitArray.ToString<[0, '.', ...DigitArray.TrimTrailingZeros<Padded>]> : SplitFloat<Padded, D[EXPONENT]> extends [infer W extends number[], infer F extends number[]] ? F extends [] ? DigitArray.ToString<W> : DigitArray.ToString<[...W, '.', ...DigitArray.TrimTrailingZeros<F>]> : never : never) extends infer R ? R extends '0' ? R : R extends string ? D[SIGN] extends '-' ? `-${R}` : R : never : never;
+    /**
+     * Splits DigitArray into the whole number and the fractional part.
+     *
+     * @note cannot use `ArrayPlus.SplitAt` as it causes infinite loop.
+     */
+    type SplitFloat<A extends number[], I extends number, F extends number[] = []> = I extends 0 ? [A, []] : F['length'] extends I ? [A, F] : A extends [...infer H extends number[], infer T extends number] ? SplitFloat<H, I, [T, ...F]> : never;
+    /**
+     * Normalizes a `DigitsStruct`.
+     *
+     * The normalization two two things:
+     *
+     * - if the first digit is negative, it will flip the sign.
+     * - carry digits if the digit is negative or greater than 9.
+     */
+    export type Normalize<N extends DigitsStruct, R extends DigitsStruct = ['+', [], 0]> = `${N[DIGITS][0]}` extends `-${number}` ? Normalize<FlipSign<N>, R> : [N[SIGN], DigitArray.CarryDigits<N[DIGITS]>, N[EXPONENT]];
+    type FlipSign<D extends DigitsStruct, I extends number[] = D[DIGITS], R extends number[] = []> = I extends [] ? D[SIGN] extends '-' ? ['+', R, D[EXPONENT]] : ['-', R, D[EXPONENT]] : I extends [infer H extends number, ...infer T extends number[]] ? FlipSign<D, T, [...R, Digit.FlipSign<H>]> : never;
+    /**
+     * Add `A` and `B`.
+     *
+     * @template A A normalized `DigitsStruct`.
+     * @template B B normalized `DigitsStruct`.
+     */
+    export type Add<A extends DigitsStruct, B extends DigitsStruct> = Balance<A, B> extends [
+        infer BA extends DigitsStruct,
+        infer BB extends DigitsStruct
+    ] ? [BA[SIGN], BB[SIGN]] extends ['+', '+'] ? Normalize<['+', DigitArray.Add<BA[DIGITS], BB[DIGITS]>, BA[EXPONENT]]> : [BA[SIGN], BB[SIGN]] extends ['+', '-'] ? Normalize<['+', DigitArray.Subtract<BA[DIGITS], BB[DIGITS]>, BA[EXPONENT]]> : [BA[SIGN], BB[SIGN]] extends ['-', '+'] ? Normalize<['+', DigitArray.Subtract<BB[DIGITS], BA[DIGITS]>, BB[EXPONENT]]> : [BA[SIGN], BB[SIGN]] extends ['-', '-'] ? Normalize<['-', DigitArray.Add<BA[DIGITS], BB[DIGITS]>, BA[EXPONENT]]> : never : never;
+    export type Subtract<A extends DigitsStruct, B extends DigitsStruct> = Balance<A, B> extends [
+        infer BA extends DigitsStruct,
+        infer BB extends DigitsStruct
+    ] ? [BA[SIGN], BB[SIGN]] extends ['+', '+'] ? Normalize<['+', DigitArray.Subtract<BA[DIGITS], BB[DIGITS]>, BA[EXPONENT]]> : [BA[SIGN], BB[SIGN]] extends ['+', '-'] ? Normalize<['+', DigitArray.Add<BA[DIGITS], BB[DIGITS]>, BA[EXPONENT]]> : [BA[SIGN], BB[SIGN]] extends ['-', '+'] ? Normalize<['-', DigitArray.Add<BB[DIGITS], BA[DIGITS]>, BA[EXPONENT]]> : [BA[SIGN], BB[SIGN]] extends ['-', '-'] ? Normalize<['-', DigitArray.Subtract<BA[DIGITS], BB[DIGITS]>, BA[EXPONENT]]> : never : never;
+    export type Multiply<A extends DigitsStruct, B extends DigitsStruct> = NumericAdd<A[EXPONENT], B[EXPONENT]> extends infer Exp extends number ? [A[SIGN], B[SIGN]] extends ['+', '+'] ? Normalize<['+', DigitArray.Multiply<A[DIGITS], B[DIGITS]>, Exp]> : [A[SIGN], B[SIGN]] extends ['+', '-'] ? Normalize<['-', DigitArray.Multiply<A[DIGITS], B[DIGITS]>, Exp]> : [A[SIGN], B[SIGN]] extends ['-', '+'] ? Normalize<['-', DigitArray.Multiply<B[DIGITS], A[DIGITS]>, Exp]> : [A[SIGN], B[SIGN]] extends ['-', '-'] ? Normalize<['+', DigitArray.Multiply<A[DIGITS], B[DIGITS]>, Exp]> : never : never;
+    /**
+     * Balance the two structs for add/subtract.
+     */
+    export type Balance<A extends DigitsStruct, B extends DigitsStruct> = GetBalancePadding<A[EXPONENT], B[EXPONENT]> extends [infer Pads extends number[], infer Longer] ? Longer extends 'A' ? [A, [B[SIGN], DigitArray.TrimLeadingZeros<[...B[DIGITS], ...Pads]>, A[EXPONENT]]] : [[A[SIGN], DigitArray.TrimLeadingZeros<[...A[DIGITS], ...Pads]>, B[EXPONENT]], B] : never;
+    type GetBalancePadding<A extends number, B extends number, C extends number[] = [], R extends number[] = []> = A extends B ? [[], 'A'] : R extends [] ? C['length'] extends A ? GetBalancePadding<A, B, [0, ...C], [0]> : C['length'] extends B ? GetBalancePadding<A, B, [0, ...C], [0, ...R]> : GetBalancePadding<A, B, [0, ...C], []> : C['length'] extends A ? [R, 'A'] : C['length'] extends B ? [R, 'B'] : GetBalancePadding<A, B, [0, ...C], [0, ...R]>;
+    export {};
+}
+export declare namespace DigitArray {
+    export type FromString<S extends string> = S extends `1${infer L}` ? [1, ...FromString<L>] : S extends `2${infer L}` ? [2, ...FromString<L>] : S extends `3${infer L}` ? [3, ...FromString<L>] : S extends `4${infer L}` ? [4, ...FromString<L>] : S extends `5${infer L}` ? [5, ...FromString<L>] : S extends `6${infer L}` ? [6, ...FromString<L>] : S extends `7${infer L}` ? [7, ...FromString<L>] : S extends `8${infer L}` ? [8, ...FromString<L>] : S extends `9${infer L}` ? [9, ...FromString<L>] : S extends `0${infer L}` ? [0, ...FromString<L>] : S extends `-1${infer L}` ? [-1, ...FromString<L>] : S extends `-2${infer L}` ? [-2, ...FromString<L>] : S extends `-3${infer L}` ? [-3, ...FromString<L>] : S extends `-4${infer L}` ? [-4, ...FromString<L>] : S extends `-5${infer L}` ? [-5, ...FromString<L>] : S extends `-6${infer L}` ? [-6, ...FromString<L>] : S extends `-7${infer L}` ? [-7, ...FromString<L>] : S extends `-8${infer L}` ? [-8, ...FromString<L>] : S extends `-9${infer L}` ? [-9, ...FromString<L>] : S extends `-0${infer L}` ? [-0, ...FromString<L>] : [];
+    export type ToString<A extends Array<number | string>> = number extends A['length'] ? '' : A['length'] extends 0 ? '' : `${A[0]}${ToString<Tail<A>>}`;
+    export type TrimTrailingZeros<T extends number[]> = T extends [0] ? T : T extends [...infer Tail extends number[], 0] ? TrimTrailingZeros<Tail> : T;
+    export type Add<A extends number[], B extends number[], R extends number[] = []> = A extends [] ? B extends [] ? R : B extends [...infer BH extends number[], infer BL extends number] ? Add<[], BH, [BL, ...R]> : never : B extends [] ? A extends [...infer AH extends number[], infer AL extends number] ? Add<AH, [], [AL, ...R]> : never : [A, B] extends [
+        [
+            ...infer AH extends number[],
+            infer AL extends number
+        ],
+        [
+            ...infer BH extends number[],
+            infer BL extends number
+        ]
+    ] ? Add<AH, BH, [Digit.Add<AL, BL>, ...R]> : never;
+    export type Subtract<A extends number[], B extends number[], R extends number[] = []> = A extends [] ? B extends [] ? TrimLeadingZeros<R> : B extends [...infer BH extends number[], infer BL extends number] ? Subtract<[], BH, [ToNegative<BL>, ...R]> : never : B extends [] ? A extends [...infer AH extends number[], infer AL extends number] ? Subtract<AH, [], [AL, ...R]> : never : [A, B] extends [
+        [
+            ...infer AH extends number[],
+            infer AL extends number
+        ],
+        [
+            ...infer BH extends number[],
+            infer BL extends number
+        ]
+    ] ? Subtract<AH, BH, [Digit.Subtract<AL, BL>, ...R]> : never;
+    export type Multiply<A extends number[], B extends number[], R extends number[][] = []> = B extends [] ? RecursiveAdd<R> : B extends [infer Head extends number, ...infer Tail extends number[]] ? Multiply<A, Tail, [...R, CarryDigits<MultiplyArray<A, Head, Zeros<Tail['length']>>>]> : never;
+    type Zeros<N extends number, R extends number[] = []> = R['length'] extends N ? R : Zeros<N, [0, ...R]>;
+    type MultiplyArray<A extends number[], B extends number, Pad extends number[], R extends number[] = []> = B extends 0 ? [0] : B extends 1 ? [...A, ...Pad] : A extends [] ? [...R, ...Pad] : A extends [infer H extends number, ...infer T extends number[]] ? MultiplyArray<T, B, Pad, [...R, Digit.Multiply<H, B>]> : never;
+    /**
+     * Recursively add digit arrays.
+     *
+     * This is used in multiplication.
+     */
+    type RecursiveAdd<E extends number[][], R extends number[] = []> = E extends [] ? R : E extends [infer H extends number[], ...infer T extends number[][]] ? RecursiveAdd<T, CarryDigits<Add<R, H>>> : never;
+    export type CarryDigits<N extends number[], R extends number[] = []> = N extends [] ? TrimLeadingZeros<R> : N extends [infer Tail extends number] ? `${Tail}` extends `${infer T1 extends number}${infer T2 extends number}` ? CarryDigits<[], [T1, T2, ...R]> : `${Tail}` extends `-${infer T1 extends number}${infer T2 extends number}` ? `-${T1}` extends `${infer NT extends number}` ? CarryDigits<[], [NT, T2, ...R]> : never : CarryDigits<[], [Tail, ...R]> : N extends [infer Head extends number, infer Tail extends number] ? `${Tail}` extends `${infer T1 extends number}${infer T2 extends number}` ? CarryDigits<[Digit.Add<Head, T1>], [T2, ...R]> : `${Tail}` extends `-${infer T1 extends number}${infer T2 extends number}` ? `-${T1}` extends `${infer NT extends number}` ? CarryDigits<[Digit.Add<Head, NT>], [T2, ...R]> : never : `${Tail}` extends `-${number}` ? CarryDigits<[Digit.Add<Head, -1>], [Digit.Plus10[Tail], ...R]> : CarryDigits<[Head], [Tail, ...R]> : N extends [...infer Heads extends number[], infer Head extends number, infer Tail extends number] ? `${Tail}` extends `${infer T1 extends number}${infer T2 extends number}` ? CarryDigits<[...Heads, Digit.Add<Head, T1>], [T2, ...R]> : `${Tail}` extends `-${infer T1 extends number}${infer T2 extends number}` ? `-${T1}` extends `${infer NT extends number}` ? CarryDigits<[...Heads, Digit.Add<Head, NT>], [T2, ...R]> : never : `${Tail}` extends `-${number}` ? CarryDigits<[...Heads, Digit.Add<Head, -1>], [Digit.Plus10[Tail], ...R]> : CarryDigits<[...Heads, Head], [Tail, ...R]> : never;
+    export {};
+}
+export declare namespace Digit {
+    /**
+     * Adds two `Digit`.
+     *
+     * add: A: 0 - 9, B: 0 - 9
+     * normalize: [81, 81] -> [81 + 8, 1]
+     */
+    export type Add<A extends number, B extends number> = `${A}` extends `-${infer AD extends number}` ? `${B}` extends `-${infer BD extends number}` ? ToNegative<PositiveEntryAdd<AD, BD>> : Subtract<B, AD> : `${B}` extends `-${infer BD extends number}` ? Subtract<A, BD> : PositiveEntryAdd<A, B>;
+    export type FlipSign<T extends number> = T extends 0 ? 0 : `${T}` extends `-${infer R extends number}` ? R : `-${T}` extends `${infer R extends number}` ? R : never;
+    type PositiveEntryAdd<A extends number, B extends number> = [
+        [
+            0,
+            1,
+            2,
+            3,
+            4,
+            5,
+            6,
+            7,
+            8,
+            9
+        ],
+        [
+            1,
+            2,
+            3,
+            4,
+            5,
+            6,
+            7,
+            8,
+            9,
+            10
+        ],
+        [
+            2,
+            3,
+            4,
+            5,
+            6,
+            7,
+            8,
+            9,
+            10,
+            11
+        ],
+        [
+            3,
+            4,
+            5,
+            6,
+            7,
+            8,
+            9,
+            10,
+            11,
+            12
+        ],
+        [
+            4,
+            5,
+            6,
+            7,
+            8,
+            9,
+            10,
+            11,
+            12,
+            13
+        ],
+        [
+            5,
+            6,
+            7,
+            8,
+            9,
+            10,
+            11,
+            12,
+            13,
+            14
+        ],
+        [
+            6,
+            7,
+            8,
+            9,
+            10,
+            11,
+            12,
+            13,
+            14,
+            15
+        ],
+        [
+            7,
+            8,
+            9,
+            10,
+            11,
+            12,
+            13,
+            14,
+            15,
+            16
+        ],
+        [
+            8,
+            9,
+            10,
+            11,
+            12,
+            13,
+            14,
+            15,
+            16,
+            17
+        ],
+        [
+            9,
+            10,
+            11,
+            12,
+            13,
+            14,
+            15,
+            16,
+            17,
+            18
+        ],
+        [
+            10,
+            11,
+            12,
+            13,
+            14,
+            15,
+            16,
+            17,
+            18,
+            19
+        ],
+        [
+            11,
+            12,
+            13,
+            14,
+            15,
+            16,
+            17,
+            18,
+            19,
+            20
+        ],
+        [
+            12,
+            13,
+            14,
+            15,
+            16,
+            17,
+            18,
+            19,
+            20,
+            21
+        ],
+        [
+            13,
+            14,
+            15,
+            16,
+            17,
+            18,
+            19,
+            20,
+            21,
+            22
+        ],
+        [
+            14,
+            15,
+            16,
+            17,
+            18,
+            19,
+            20,
+            21,
+            22,
+            23
+        ],
+        [
+            15,
+            16,
+            17,
+            18,
+            19,
+            20,
+            21,
+            22,
+            23,
+            24
+        ],
+        [
+            16,
+            17,
+            18,
+            19,
+            20,
+            21,
+            22,
+            23,
+            24,
+            25
+        ],
+        [
+            17,
+            18,
+            19,
+            20,
+            21,
+            22,
+            23,
+            24,
+            25,
+            26
+        ],
+        [
+            18,
+            19,
+            20,
+            21,
+            22,
+            23,
+            24,
+            25,
+            26,
+            27
+        ],
+        [
+            19,
+            20,
+            21,
+            22,
+            23,
+            24,
+            25,
+            26,
+            27,
+            28
+        ],
+        [
+            20,
+            21,
+            22,
+            23,
+            24,
+            25,
+            26,
+            27,
+            28,
+            29
+        ],
+        [
+            21,
+            22,
+            23,
+            24,
+            25,
+            26,
+            27,
+            28,
+            29,
+            30
+        ],
+        [
+            22,
+            23,
+            24,
+            25,
+            26,
+            27,
+            28,
+            29,
+            30,
+            31
+        ],
+        [
+            23,
+            24,
+            25,
+            26,
+            27,
+            28,
+            29,
+            30,
+            31,
+            32
+        ],
+        [
+            24,
+            25,
+            26,
+            27,
+            28,
+            29,
+            30,
+            31,
+            32,
+            33
+        ],
+        [
+            25,
+            26,
+            27,
+            28,
+            29,
+            30,
+            31,
+            32,
+            33,
+            34
+        ],
+        [
+            26,
+            27,
+            28,
+            29,
+            30,
+            31,
+            32,
+            33,
+            34,
+            35
+        ],
+        [
+            27,
+            28,
+            29,
+            30,
+            31,
+            32,
+            33,
+            34,
+            35,
+            36
+        ],
+        [
+            28,
+            29,
+            30,
+            31,
+            32,
+            33,
+            34,
+            35,
+            36,
+            37
+        ],
+        [
+            29,
+            30,
+            31,
+            32,
+            33,
+            34,
+            35,
+            36,
+            37,
+            38
+        ],
+        [
+            30,
+            31,
+            32,
+            33,
+            34,
+            35,
+            36,
+            37,
+            38,
+            39
+        ],
+        [
+            31,
+            32,
+            33,
+            34,
+            35,
+            36,
+            37,
+            38,
+            39,
+            40
+        ],
+        [
+            32,
+            33,
+            34,
+            35,
+            36,
+            37,
+            38,
+            39,
+            40,
+            41
+        ],
+        [
+            33,
+            34,
+            35,
+            36,
+            37,
+            38,
+            39,
+            40,
+            41,
+            42
+        ],
+        [
+            34,
+            35,
+            36,
+            37,
+            38,
+            39,
+            40,
+            41,
+            42,
+            43
+        ],
+        [
+            35,
+            36,
+            37,
+            38,
+            39,
+            40,
+            41,
+            42,
+            43,
+            44
+        ],
+        [
+            36,
+            37,
+            38,
+            39,
+            40,
+            41,
+            42,
+            43,
+            44,
+            45
+        ],
+        [
+            37,
+            38,
+            39,
+            40,
+            41,
+            42,
+            43,
+            44,
+            45,
+            46
+        ],
+        [
+            38,
+            39,
+            40,
+            41,
+            42,
+            43,
+            44,
+            45,
+            46,
+            47
+        ],
+        [
+            39,
+            40,
+            41,
+            42,
+            43,
+            44,
+            45,
+            46,
+            47,
+            48
+        ],
+        [
+            40,
+            41,
+            42,
+            43,
+            44,
+            45,
+            46,
+            47,
+            48,
+            49
+        ],
+        [
+            41,
+            42,
+            43,
+            44,
+            45,
+            46,
+            47,
+            48,
+            49,
+            50
+        ],
+        [
+            42,
+            43,
+            44,
+            45,
+            46,
+            47,
+            48,
+            49,
+            50,
+            51
+        ],
+        [
+            43,
+            44,
+            45,
+            46,
+            47,
+            48,
+            49,
+            50,
+            51,
+            52
+        ],
+        [
+            44,
+            45,
+            46,
+            47,
+            48,
+            49,
+            50,
+            51,
+            52,
+            53
+        ],
+        [
+            45,
+            46,
+            47,
+            48,
+            49,
+            50,
+            51,
+            52,
+            53,
+            54
+        ],
+        [
+            46,
+            47,
+            48,
+            49,
+            50,
+            51,
+            52,
+            53,
+            54,
+            55
+        ],
+        [
+            47,
+            48,
+            49,
+            50,
+            51,
+            52,
+            53,
+            54,
+            55,
+            56
+        ],
+        [
+            48,
+            49,
+            50,
+            51,
+            52,
+            53,
+            54,
+            55,
+            56,
+            57
+        ],
+        [
+            49,
+            50,
+            51,
+            52,
+            53,
+            54,
+            55,
+            56,
+            57,
+            58
+        ],
+        [
+            50,
+            51,
+            52,
+            53,
+            54,
+            55,
+            56,
+            57,
+            58,
+            59
+        ],
+        [
+            51,
+            52,
+            53,
+            54,
+            55,
+            56,
+            57,
+            58,
+            59,
+            60
+        ],
+        [
+            52,
+            53,
+            54,
+            55,
+            56,
+            57,
+            58,
+            59,
+            60,
+            61
+        ],
+        [
+            53,
+            54,
+            55,
+            56,
+            57,
+            58,
+            59,
+            60,
+            61,
+            62
+        ],
+        [
+            54,
+            55,
+            56,
+            57,
+            58,
+            59,
+            60,
+            61,
+            62,
+            63
+        ],
+        [
+            55,
+            56,
+            57,
+            58,
+            59,
+            60,
+            61,
+            62,
+            63,
+            64
+        ],
+        [
+            56,
+            57,
+            58,
+            59,
+            60,
+            61,
+            62,
+            63,
+            64,
+            65
+        ],
+        [
+            57,
+            58,
+            59,
+            60,
+            61,
+            62,
+            63,
+            64,
+            65,
+            66
+        ],
+        [
+            58,
+            59,
+            60,
+            61,
+            62,
+            63,
+            64,
+            65,
+            66,
+            67
+        ],
+        [
+            59,
+            60,
+            61,
+            62,
+            63,
+            64,
+            65,
+            66,
+            67,
+            68
+        ],
+        [
+            60,
+            61,
+            62,
+            63,
+            64,
+            65,
+            66,
+            67,
+            68,
+            69
+        ],
+        [
+            61,
+            62,
+            63,
+            64,
+            65,
+            66,
+            67,
+            68,
+            69,
+            70
+        ],
+        [
+            62,
+            63,
+            64,
+            65,
+            66,
+            67,
+            68,
+            69,
+            70,
+            71
+        ],
+        [
+            63,
+            64,
+            65,
+            66,
+            67,
+            68,
+            69,
+            70,
+            71,
+            72
+        ],
+        [
+            64,
+            65,
+            66,
+            67,
+            68,
+            69,
+            70,
+            71,
+            72,
+            73
+        ],
+        [
+            65,
+            66,
+            67,
+            68,
+            69,
+            70,
+            71,
+            72,
+            73,
+            74
+        ],
+        [
+            66,
+            67,
+            68,
+            69,
+            70,
+            71,
+            72,
+            73,
+            74,
+            75
+        ],
+        [
+            67,
+            68,
+            69,
+            70,
+            71,
+            72,
+            73,
+            74,
+            75,
+            76
+        ],
+        [
+            68,
+            69,
+            70,
+            71,
+            72,
+            73,
+            74,
+            75,
+            76,
+            77
+        ],
+        [
+            69,
+            70,
+            71,
+            72,
+            73,
+            74,
+            75,
+            76,
+            77,
+            78
+        ],
+        [
+            70,
+            71,
+            72,
+            73,
+            74,
+            75,
+            76,
+            77,
+            78,
+            79
+        ],
+        [
+            71,
+            72,
+            73,
+            74,
+            75,
+            76,
+            77,
+            78,
+            79,
+            80
+        ],
+        [
+            72,
+            73,
+            74,
+            75,
+            76,
+            77,
+            78,
+            79,
+            80,
+            81
+        ],
+        [
+            73,
+            74,
+            75,
+            76,
+            77,
+            78,
+            79,
+            80,
+            81,
+            82
+        ],
+        [
+            74,
+            75,
+            76,
+            77,
+            78,
+            79,
+            80,
+            81,
+            82,
+            83
+        ],
+        [
+            75,
+            76,
+            77,
+            78,
+            79,
+            80,
+            81,
+            82,
+            83,
+            84
+        ],
+        [
+            76,
+            77,
+            78,
+            79,
+            80,
+            81,
+            82,
+            83,
+            84,
+            85
+        ],
+        [
+            77,
+            78,
+            79,
+            80,
+            81,
+            82,
+            83,
+            84,
+            85,
+            86
+        ],
+        [
+            78,
+            79,
+            80,
+            81,
+            82,
+            83,
+            84,
+            85,
+            86,
+            87
+        ],
+        [
+            79,
+            80,
+            81,
+            82,
+            83,
+            84,
+            85,
+            86,
+            87,
+            88
+        ],
+        [
+            80,
+            81,
+            82,
+            83,
+            84,
+            85,
+            86,
+            87,
+            88,
+            89
+        ],
+        [
+            81,
+            82,
+            83,
+            84,
+            85,
+            86,
+            87,
+            88,
+            89,
+            90
+        ]
+    ][A][B];
+    /**
+     * Subtract two positive numbers.
+     * The number range from 0 to 81.
+     */
+    export type Subtract<A extends number, B extends number> = [`${A}`, `${B}`] extends [
+        `${number}${infer A2 extends number}`,
+        `${number}${infer B2 extends number}`
+    ] ? Subtract<A2, B2> : `${A}` extends `${number}${infer A2 extends number}` ? Subtract<A2, B> : `${B}` extends `${number}${infer B2 extends number}` ? Subtract<A, B2> : SingleDigitSubtract<A, B>;
+    export type SingleDigitSubtract<A extends number, B extends number> = [
+        [
+            0,
+            -1,
+            -2,
+            -3,
+            -4,
+            -5,
+            -6,
+            -7,
+            -8,
+            -9
+        ],
+        [
+            1,
+            0,
+            -1,
+            -2,
+            -3,
+            -4,
+            -5,
+            -6,
+            -7,
+            -8
+        ],
+        [
+            2,
+            1,
+            0,
+            -1,
+            -2,
+            -3,
+            -4,
+            -5,
+            -6,
+            -7
+        ],
+        [
+            3,
+            2,
+            1,
+            0,
+            -1,
+            -2,
+            -3,
+            -4,
+            -5,
+            -6
+        ],
+        [
+            4,
+            3,
+            2,
+            1,
+            0,
+            -1,
+            -2,
+            -3,
+            -4,
+            -5
+        ],
+        [
+            5,
+            4,
+            3,
+            2,
+            1,
+            0,
+            -1,
+            -2,
+            -3,
+            -4
+        ],
+        [
+            6,
+            5,
+            4,
+            3,
+            2,
+            1,
+            0,
+            -1,
+            -2,
+            -3
+        ],
+        [
+            7,
+            6,
+            5,
+            4,
+            3,
+            2,
+            1,
+            0,
+            -1,
+            -2
+        ],
+        [
+            8,
+            7,
+            6,
+            5,
+            4,
+            3,
+            2,
+            1,
+            0,
+            -1
+        ],
+        [
+            9,
+            8,
+            7,
+            6,
+            5,
+            4,
+            3,
+            2,
+            1,
+            0
+        ]
+    ][A][B];
+    export type Plus10 = {
+        [k in number]: number;
+    } & {
+        '-1': 9;
+        '-2': 8;
+        '-3': 7;
+        '-4': 6;
+        '-5': 5;
+        '-6': 4;
+        '-7': 3;
+        '-8': 2;
+        '-9': 1;
+    };
+    export type Multiply<A extends number, B extends number> = [
+        [
+            0,
+            0,
+            0,
+            0,
+            0,
+            0,
+            0,
+            0,
+            0,
+            0
+        ],
+        [
+            0,
+            1,
+            2,
+            3,
+            4,
+            5,
+            6,
+            7,
+            8,
+            9
+        ],
+        [
+            0,
+            2,
+            4,
+            6,
+            8,
+            10,
+            12,
+            14,
+            16,
+            18
+        ],
+        [
+            0,
+            3,
+            6,
+            9,
+            12,
+            15,
+            18,
+            21,
+            24,
+            27
+        ],
+        [
+            0,
+            4,
+            8,
+            12,
+            16,
+            20,
+            24,
+            28,
+            32,
+            36
+        ],
+        [
+            0,
+            5,
+            10,
+            15,
+            20,
+            25,
+            30,
+            35,
+            40,
+            45
+        ],
+        [
+            0,
+            6,
+            12,
+            18,
+            24,
+            30,
+            36,
+            42,
+            48,
+            54
+        ],
+        [
+            0,
+            7,
+            14,
+            21,
+            28,
+            35,
+            42,
+            49,
+            56,
+            63
+        ],
+        [
+            0,
+            8,
+            16,
+            24,
+            32,
+            40,
+            48,
+            56,
+            64,
+            72
+        ],
+        [
+            0,
+            9,
+            18,
+            27,
+            36,
+            45,
+            54,
+            63,
+            72,
+            81
+        ]
+    ][A][B];
+    export {};
+}
+export {};
+//# sourceMappingURL=numeric_struct.d.ts.map