type-plus 6.8.1 → 7.0.0

package/ts/math/max.ts

@@ -0,0 +1,13 @@
+import type { IsNever } from '../never/never_type.js'
+import type { GreaterThan } from './greater_than.js'
+
+export type Max<A extends number | bigint, B extends number | bigint, Fail = never> = GreaterThan<
+	A,
+	B
+> extends infer Result
+	? IsNever<Result> extends true
+		? Fail
+		: Result extends true
+		? A
+		: B
+	: never

package/ts/math/multiply.ts

@@ -0,0 +1,12 @@
+import type { NumericStruct } from './numeric_struct.js'
+
+export type Multiply<A extends number | bigint, B extends number | bigint, Fail = never> = [
+	NumericStruct.FromNumeric<A, Fail>,
+	NumericStruct.FromNumeric<B, Fail>
+] extends [infer MA, infer MB]
+	? MA extends NumericStruct
+		? MB extends NumericStruct
+			? NumericStruct.ToNumeric<NumericStruct.Multiply<MA, MB>>
+			: Fail
+		: Fail
+	: never

package/ts/math/numeric_struct.ts

@@ -0,0 +1,658 @@
+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]
+// These are used to reference the NumericStruct values
+export type TYPE = 0
+export type DIGITS_STRUCT = 1
+
+export namespace NumericStruct {
+	/**
+	 * Creates a `NumericStruct` from number or bigint `N`.
+	 */
+	export 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`.
+	 */
+	export 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
+
+	export type Add<A extends NumericStruct, B extends NumericStruct> = [
+		A[TYPE],
+		DigitsStruct.Add<A[DIGITS_STRUCT], B[DIGITS_STRUCT]>
+	]
+
+	export type Subtract<A extends NumericStruct, B extends NumericStruct> = [
+		A[TYPE],
+		DigitsStruct.Subtract<A[DIGITS_STRUCT], B[DIGITS_STRUCT]>
+	]
+
+	export type Multiply<A extends NumericStruct, B extends NumericStruct> = [
+		A[TYPE],
+		DigitsStruct.Multiply<A[DIGITS_STRUCT], B[DIGITS_STRUCT]>
+	]
+}
+
+// TODO: move into `NumericHelpers`
+type StringToBigint<S extends string, Fail> = S extends `${infer N extends bigint}` ? N : Fail
+
+// TODO: move into `NumericHelpers`
+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]
+// These are used to reference the DigitsStruct values
+export type SIGN = 0
+export type DIGITS = 1
+export type EXPONENT = 2
+
+export 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 []
+		? // have not reach min yet
+		  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]>
+
+	/**
+	 * This is used to align the `NumberStruct` during `Add/Subtract`.
+	 * @internal
+	 */
+	export type GetMinPadEnd<
+		A extends number,
+		B extends number,
+		R extends number[] = []
+	> = R['length'] extends A ? [R, 'B'] : R['length'] extends B ? [R, 'A'] : GetMinPadEnd<A, B, [0, ...R]>
+}
+
+export 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>>}`
+
+	/**
+	 * [0, 0, -1] => [-1]
+	 *
+	 * This is used in various places so that there will be less computation,
+	 * and the sign bit can be handled properly.
+	 * @internal
+	 */
+	export type TrimLeadingZeros<T extends number[]> = T extends [0]
+		? T
+		: T extends [0, ...infer Tail extends number[]]
+		? TrimLeadingZeros<Tail>
+		: T
+	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 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]
+}

package/ts/math/subtract.ts

@@ -0,0 +1,14 @@
+import type { NumericStruct } from './numeric_struct.js'
+
+export type Subtract<A extends number | bigint, B extends number | bigint, Fail = never> = [
+	NumericStruct.FromNumeric<A, Fail>,
+	NumericStruct.FromNumeric<B, Fail>
+] extends [infer MA, infer MB]
+	? MA extends NumericStruct
+		? MB extends NumericStruct
+			? NumericStruct.ToNumeric<NumericStruct.Subtract<MA, MB>>
+			: Fail
+		: Fail
+	: never
+
+export type Decrement<N extends number | bigint> = Subtract<N, 1>