Press n or j to go to the next uncovered block, b, p or k for the previous block.
| 1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 19 20 21 22 23 24 25 26 27 28 29 30 31 32 33 34 35 36 37 38 39 40 41 42 43 44 45 46 47 48 49 50 51 52 53 54 55 56 57 58 59 60 61 62 63 64 65 66 67 68 69 70 71 72 73 74 75 76 77 78 79 80 81 82 83 84 85 86 87 88 89 90 91 92 93 94 95 96 97 98 99 100 101 102 103 104 105 106 107 108 109 110 111 112 113 114 115 116 117 118 119 120 121 122 123 124 125 126 127 128 129 130 131 132 133 134 135 136 137 138 139 140 141 142 143 144 145 146 147 148 149 150 151 152 153 154 155 156 157 158 159 160 161 162 163 164 165 166 167 168 169 170 171 172 173 174 175 176 177 178 179 180 181 182 183 184 185 186 187 188 189 190 191 192 193 194 195 196 197 198 199 200 201 202 203 204 205 206 207 208 209 210 211 212 213 214 215 216 217 218 219 220 221 222 223 224 225 226 227 228 229 230 231 232 233 234 235 236 237 238 239 240 241 242 243 244 245 246 247 248 249 250 251 252 253 254 255 256 257 258 259 260 261 262 263 264 | 494x 12x 12x 482x 482x 657x 32x 32x 625x 625x 150x 150x 150x 420x 420x 150x 196x 196x 20x 20x 20x 48x 176x 176x 176x 402x 1845x 17x 1828x 20x 1808x 20x 1788x 372x 17x 355x 20x 335x 20x 315x 3658x 88x 3570x 20x 3550x 82x 3468x 1794x 3015x 510x 1136x 2930x 1794x 1424x 900x 1136x 17x 62x 17x 62x 160x 148x 160x 148x 1907x 333x 333x 1574x 46x 46x 46x 1528x 46x 46x 46x 1482x 200x 797x 173x 265x 47x 17x | import {
allocate,
Dinero,
equal as dineroEqual,
greaterThan as dineroGreaterThan,
greaterThanOrEqual as dineroGreaterThanOrEqual,
lessThan as dineroLessThan,
lessThanOrEqual as dineroLessThanOrEqual,
} from "dinero.js";
import { Amount, Fraction } from "../value.js";
import {
atd,
crossMinus,
crossMultiply,
crossPlus,
dta,
mixMinus,
mixMultiply,
mixPlus,
polarityFix,
simpleDivide,
simpleMinus,
simpleMultiply,
simplePlus,
unity,
} from "./math-low-level.js";
function absolute(a: Fraction): Fraction;
function absolute(a: Amount): Amount;
function absolute(a: unknown): unknown {
if (Array.isArray(a)) {
const [n, d] = polarityFix(a as Fraction);
return [absolute(n), d];
} else {
const { amount, scale } = a as Amount;
return {
amount: amount < 0n ? -amount : amount,
scale,
} as Amount;
}
}
function negate(a: Amount): Amount;
function negate(a: Fraction): Fraction;
function negate(a: unknown): unknown {
if (Array.isArray(a)) {
const [n, d] = a as Fraction;
return polarityFix([negate(n), d]);
} else {
const { amount, scale } = a as Amount;
return {
amount: -amount,
scale,
} as Amount;
}
}
/**
* Remainder of **a** divided by **b**
* @param a numerator
* @param b denominator
*/
function remainder(a: Amount, b: Amount): [bigint, Amount] {
let remain = absolute(a);
let count = 0n;
while (minus(remain, b).amount >= 0n) {
remain = minus(remain, b);
count++;
}
return [count, remain];
}
function split<T extends Amount[]>(a: Amount, b: [...T]): [...T];
function split<T extends Amount[]>(
a: Fraction,
b: T,
): { [K in keyof T]: Fraction };
function split(a: unknown, b: unknown): unknown {
const alloc = b as Amount[];
if (Array.isArray(a)) {
const [inn, idn] = a as Fraction;
const i = atd(inn);
const ans = allocate(i, alloc);
return ans.map((x) => polarityFix([dta(x), idn]));
} else {
const input = a as Amount;
const i = atd(input);
const ans = allocate(i, alloc);
return ans.map((x) => dta(x));
}
}
function minus(a: Amount, b: Amount): Amount;
function minus(a: Amount, b: Fraction): Fraction;
function minus(a: Fraction, b: Amount): Fraction;
function minus(a: Fraction, b: Fraction): Fraction;
function minus(a: unknown, b: unknown): unknown {
if (Array.isArray(a) && Array.isArray(b)) {
return crossMinus(a as Fraction, b as Fraction);
} else if (Array.isArray(a) && !Array.isArray(b)) {
return negate(mixMinus(b as Amount, a as Fraction));
} else if (Array.isArray(b) && !Array.isArray(a)) {
return mixMinus(a as Amount, b as Fraction);
} else {
return simpleMinus(a as Amount, b as Amount);
}
}
function plus(a: Amount, b: Amount): Amount;
function plus(a: Amount, b: Fraction): Fraction;
function plus(a: Fraction, b: Amount): Fraction;
function plus(a: Fraction, b: Fraction): Fraction;
function plus(a: unknown, b: unknown): unknown {
if (Array.isArray(a) && Array.isArray(b)) {
return crossPlus(a as Fraction, b as Fraction);
} else if (Array.isArray(a) && !Array.isArray(b)) {
return mixPlus(b as Amount, a as Fraction);
} else if (Array.isArray(b) && !Array.isArray(a)) {
return mixPlus(a as Amount, b as Fraction);
} else {
return simplePlus(a as Amount, b as Amount);
}
}
function times(a: Amount, b: Amount): Amount;
function times(a: Amount, b: Fraction): Amount;
function times(a: Fraction, b: Amount): Amount;
function times(a: Fraction, b: Fraction): Fraction;
function times(a: unknown, b: unknown): unknown {
if (Array.isArray(a) && Array.isArray(b)) {
return crossMultiply(a as Fraction, b as Fraction);
} else if (Array.isArray(a) && !Array.isArray(b)) {
return mixMultiply(b as Amount, a as Fraction);
} else if (Array.isArray(b) && !Array.isArray(a)) {
return mixMultiply(a as Amount, b as Fraction);
} else {
return simpleMultiply(a as Amount, b as Amount);
}
}
function filterUniqueObjects(
value: Amount,
index: number,
self: Amount[],
): boolean {
return (
self.findIndex(
(o) => o.amount === value.amount && o.scale === value.scale,
) === index
);
}
function normalize<T extends Fraction[]>(amt: [...T]): [...T] {
return amt.map(([n, d], i) => {
const m = amt
.filter((_, j) => i != j)
.map(([, denominator]) => denominator)
.filter(filterUniqueObjects)
.filter((x) => x.amount !== d.amount || x.scale !== d.scale)
.reduce((amount, a) => times(amount, a), unity);
return [times(n, m), times(d, m)];
}) as T;
}
function max<T extends Amount>(...vals: T[]): T | undefined;
function max<T extends Fraction>(...vals: T[]): T | undefined;
function max<T extends Amount | Fraction>(...vals: T[]): T | undefined;
function max<T>(...vals: unknown[]): unknown {
const fracs = vals.map((a) =>
Array.isArray(a) ? (a as Fraction) : ([a, unity] as Fraction),
);
return vals[
fracs.reduce((max, val, i) => {
return greaterThan(val, fracs[max]!) ? i : max;
}, 0)
] as T;
}
function min<T extends Amount>(...vals: T[]): T | undefined;
function min<T extends Fraction>(...vals: T[]): T | undefined;
function min<T extends Amount | Fraction>(...vals: T[]): T | undefined;
function min<T>(...vals: unknown[]): unknown {
const fracs = vals.map((a) =>
Array.isArray(a) ? (a as Fraction) : ([a, unity] as Fraction),
);
return vals[
fracs.reduce((min, val, i) => {
return lessThan(val, fracs[min]!) ? i : min;
}, 0)
] as T;
}
type ComparisonOp = (a: Dinero<bigint>, b: Dinero<bigint>) => boolean;
function compare(
a: Amount | Fraction,
b: Amount | Fraction,
op: ComparisonOp,
): boolean {
if (Array.isArray(a) && Array.isArray(b)) {
const [[an], [bn]] = normalize([a, b]);
return compare(an, bn, op);
} else if (Array.isArray(a) && !Array.isArray(b)) {
const bn = b;
const bd = unity;
return compare(a, [bn, bd], op);
} else if (!Array.isArray(a) && Array.isArray(b)) {
const an = a;
const ad = unity;
return compare([an, ad], b, op);
} else {
return op(atd(a as Amount), atd(b as Amount));
}
}
function equal(a: Amount | Fraction, b: Amount | Fraction): boolean {
return compare(a, b, dineroEqual);
}
function lessThan(a: Amount | Fraction, b: Amount | Fraction): boolean {
return compare(a, b, dineroLessThan);
}
function lessThanOrEqual(a: Amount | Fraction, b: Amount | Fraction): boolean {
return compare(a, b, dineroLessThanOrEqual);
}
function greaterThan(a: Amount | Fraction, b: Amount | Fraction): boolean {
return compare(a, b, dineroGreaterThan);
}
function greaterThanOrEqual(
a: Amount | Fraction,
b: Amount | Fraction,
): boolean {
return compare(a, b, dineroGreaterThanOrEqual);
}
function divide(a: Amount, b: Amount): Amount {
return simpleDivide(a, b);
}
export {
remainder,
absolute,
negate,
minus,
times,
plus,
split,
normalize,
max,
min,
equal,
lessThan,
lessThanOrEqual,
greaterThan,
greaterThanOrEqual,
divide,
};
|