JavaScript: Math, 41–79

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
38const gcd = (a, b) => {
  a = Math.abs(a);
  b = Math.abs(b);
  while (b) [a, b] = [b, a % b];
  return a;
};

const coprime = (a, b) => gcd(a, b) === 1;

// Count them directly.
const totientByCounting = (n) => {
  let count = 0;
  for (let k = 1; k <= n; k++) if (coprime(k, n)) count++;
  return count;
};

// Or derive it from the distinct primes dividing n.
const distinctPrimes = (n) => {
  const out = [];
  for (let d = 2; d * d <= n; d++) {
    if (n % d !== 0) continue;
    out.push(d);
    while (n % d === 0) n /= d;
  }
  if (n > 1) out.push(n);
  return out;
};
const totient = (n) => distinctPrimes(n).reduce((acc, p) => (acc / p) * (p - 1), n);

const consecutive = Array.from({ length: 20 }, (_, i) => coprime(i + 1, i + 2));
const gapOfTwo = Array.from({ length: 8 }, (_, i) => coprime(i + 1, i + 3));

console.log('8 and 15 :', coprime(8, 15), '<- neither is prime');
console.log('8 and 12 :', coprime(8, 12));
console.log('totient of 10, by counting:', totientByCounting(10), 'by formula:', totient(10));
console.log('totient of 1000           :', totientByCounting(1000), totient(1000));
console.log('n with n+1               :', consecutive.every(Boolean));
console.log('n with n+2               :', gapOfTwo);

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
30const digitSumByString = (n) =>
  String(Math.abs(n)).split('').reduce((sum, ch) => sum + Number(ch), 0);

function digitSum(n) {
  n = Math.abs(n);
  let sum = 0;
  while (n > 0) {
    sum += n % 10;
    n = Math.floor(n / 10);
  }
  return sum;
}

const digitalRootByLoop = (n) => {
  n = Math.abs(n);
  while (n > 9) n = digitSum(n);
  return n;
};

// Same answer, no loop: the root is n mod 9, with 9 in place of 0.
const digitalRoot = (n) => (n === 0 ? 0 : 1 + ((Math.abs(n) - 1) % 9));

const chain = [9875, digitSum(9875), digitSum(29), digitSum(11)];

console.log('digit sum of 9875 :', digitSum(9875));
console.log('the chain to a root:', chain);
console.log('closed form        :', digitalRoot(9875));
console.log('String(1e21)       :', String(1e21));
console.log('by string          :', digitSumByString(1e21), '<- the e and the + are not digits');
console.log('by arithmetic      :', digitSum(1e21));

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23function reverseDigits(n) {
  const sign = Math.sign(n);
  let rest = Math.abs(n);
  let out = 0;
  while (rest > 0) {
    out = out * 10 + (rest % 10);
    rest = Math.floor(rest / 10);
  }
  return sign * out;
}

const reverseByString = (n) =>
  Math.sign(n) * Number(String(Math.abs(n)).split('').reverse().join(''));

const big = 12345678901234567;          // 17 digits, and already not what it says

console.log('12345 ->', reverseDigits(12345));
console.log('1200  ->', reverseDigits(1200), '<- the zeros are gone for good');
console.log('back  ->', reverseDigits(reverseDigits(1200)));
console.log('-123  ->', reverseDigits(-123));
console.log('the 17-digit literal:', big);
console.log('reversed            :', reverseDigits(big));
console.log('MAX_SAFE reversed   :', reverseDigits(Number.MAX_SAFE_INTEGER));

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
44const isPalindrome = (n) => {
  const s = String(n);
  return s === [...s].reverse().join('');
};

// No strings: rebuild the number backwards and compare.
function isPalindromeByMaths(n) {
  if (n < 0) return false;
  let rest = n;
  let reversed = 0;
  while (rest > 0) {
    reversed = reversed * 10 + (rest % 10);
    rest = Math.floor(rest / 10);
  }
  return reversed === n;
}

function largestProductPalindrome(low, high) {
  let best = 0;
  let pair = null;
  for (let a = low; a <= high; a++) {
    for (let b = a; b <= high; b++) {
      const p = a * b;
      if (p > best && isPalindrome(p)) {
        best = p;
        pair = [a, b];
      }
    }
  }
  return { best, pair };
}

const twoDigit = largestProductPalindrome(10, 99);
const threeDigit = largestProductPalindrome(100, 999);

const below1000 = [];
for (let n = 0; n < 1000; n++) if (isPalindrome(n)) below1000.push(n);

console.log('121, 123, 1221 :', [121, 123, 1221].map(isPalindrome));
console.log('10             :', isPalindrome(10), '<- 10 reversed is 1');
console.log('-121           :', isPalindrome(-121), isPalindromeByMaths(-121));
console.log('two-digit best :', twoDigit);
console.log('three-digit    :', threeDigit);
console.log('585 in binary  :', (585).toString(2));

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
31const digitsByString = (n) => String(Math.abs(n)).length;
const digitsByLog = (n) => Math.floor(Math.log10(Math.abs(n))) + 1;

function digitsByLoop(n) {
  n = Math.abs(Math.trunc(n));
  let count = 0;
  do {
    count++;
    n = Math.floor(n / 10);
  } while (n > 0);
  return count;                        // do..while, so 0 has one digit
}

const nines = 999999999999999;         // fifteen of them
const huge = 1e21;

let firstDisagreement = 'none below 10000';
for (let n = 1; n < 10000; n++) {
  if (digitsByString(n) !== digitsByLog(n) || digitsByString(n) !== digitsByLoop(n)) {
    firstDisagreement = n;
    break;
  }
}

console.log('digits of 42, 1000 :', [42, 1000].map(digitsByLoop));
console.log('all three agree to 10000?', firstDisagreement);
console.log('fifteen nines      :', nines);
console.log('log10 of it        :', Math.log10(nines), '<- rounded up to a whole number');
console.log('so log10 says      :', digitsByLog(nines), 'but there are', digitsByLoop(nines));
console.log('String(1e21)       :', String(huge), 'length', digitsByString(huge));
console.log('BigInt(1e21)       :', BigInt(huge).toString().length, 'digits');

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
28function digitSum(n) {
  let rest = Math.abs(n);
  let sum = 0;
  while (rest > 0) {
    sum += rest % 10;
    rest = Math.floor(rest / 10);
  }
  return sum;
}

const isHarshad = (n) => n > 0 && n % digitSum(n) === 0;

const upTo30 = [];
for (let n = 1; n <= 30; n++) if (isHarshad(n)) upTo30.push(n);

const upTo100 = [];
for (let n = 1; n <= 100; n++) if (isHarshad(n)) upTo100.push(n);

const primes = [11, 13, 17, 19, 23, 29, 31, 37, 41, 43, 47, 53, 59, 61, 67, 71, 73, 79, 83, 89, 97];

let firstMiss = 0;
for (let n = 101; !firstMiss; n++) if (!isHarshad(n)) firstMiss = n;

console.log('Harshad up to 30 :', upTo30);
console.log('how many to 100  :', upTo100.length);
console.log('18 and 19        :', [18, 19].map((n) => [n, digitSum(n), isHarshad(n)]));
console.log('1729             :', digitSum(1729), 1729 / 19);
console.log('first miss > 100 :', firstMiss);

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22function isPerfectSquare(n) {
  if (!Number.isInteger(n) || n < 0) return false;
  const root = Math.round(Math.sqrt(n));
  return root * root === n;            // integer multiply, exact comparison
}

const roundTripFails = [];
for (let n = 0; n < 200; n++) if (Math.sqrt(n) ** 2 !== n) roundTripFails.push(n);

let allSquaresPass = true;
for (let k = 0; k <= 1000; k++) if (!isPerfectSquare(k * k)) allSquaresPass = false;

const lastSafeRoot = 94906265;         // 94906265 squared is still a safe integer
const lastDigits = [...new Set(Array.from({ length: 200 }, (_, i) => (i * i) % 10))].sort((a, b) => a - b);
const digitalRoots = [...new Set(Array.from({ length: 200 }, (_, i) => (i === 0 ? 0 : 1 + ((i * i - 1) % 9))))].sort((a, b) => a - b);

console.log('16, 25, 26     :', [16, 25, 26].map(isPerfectSquare));
console.log('failures of sqrt(n) ** 2 === n below 200:', roundTripFails.length);
console.log('first few      :', roundTripFails.slice(0, 6));
console.log('2 ** 53        :', Math.sqrt(2 ** 53), '<- not a whole root');
console.log('largest safe square:', lastSafeRoot * lastSafeRoot);
console.log('last digits of squares:', lastDigits);

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19const byBits = (n) => n > 0 && (n & (n - 1)) === 0;
const byLog = (n) => n > 0 && Number.isInteger(n) && Number.isInteger(Math.log2(n));

// Slow, and right: divide out every factor of 2 and see what is left.
function byHalving(n) {
  if (!Number.isInteger(n) || n < 1) return false;
  while (n % 2 === 0) n /= 2;
  return n === 1;
}

const beyond32 = 2 ** 32 + 1;          // 4294967297, plainly not a power of two
const odd49 = 2 ** 49 + 1;             // 562949953421313, also plainly not

console.log('small values   :', [1, 2, 3, 4, 1023, 1024].map(byBits));
console.log('2**32 + 1      :', byBits(beyond32), '<- wrong');
console.log('coerced to int32:', beyond32 | 0, 'and 3 * 2**32 becomes', (3 * 2 ** 32) | 0);
console.log('by log2        :', byLog(beyond32), '<- fixed');
console.log('2**49 + 1      :', byLog(odd49), '<- wrong again, log2 says', Math.log2(odd49));
console.log('by halving     :', [beyond32, odd49].map(byHalving));

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24function isArmstrong(n) {
  const digits = String(n).split('').map(Number);
  const power = digits.length;
  const sum = digits.reduce((acc, d) => acc + d ** power, 0);
  return sum === n;
}

const below10000 = [];
for (let n = 0; n < 10000; n++) if (isArmstrong(n)) below10000.push(n);

const twoDigit = below10000.filter((n) => n >= 10 && n < 100);

const fiveDigit = [];
for (let n = 10000; n < 100000; n++) if (isArmstrong(n)) fiveDigit.push(n);

// The same digits with a fixed exponent of 3 answer a different question.
const cubeSum = (n) => String(n).split('').reduce((acc, c) => acc + Number(c) ** 3, 0);

console.log('153 as cubes  :', [1 ** 3, 5 ** 3, 3 ** 3], 'summing to', cubeSum(153));
console.log('below 10000   :', below10000);
console.log('two-digit ones:', twoDigit);
console.log('five-digit    :', fiveDigit);
console.log('9474 as fourth powers:', [9 ** 4, 4 ** 4, 7 ** 4, 4 ** 4].reduce((a, b) => a + b, 0));
console.log('but 9474 as cubes    :', cubeSum(9474));

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
56function squareDigits(n) {
  let rest = n;
  let sum = 0;
  while (rest > 0) {
    const d = rest % 10;
    sum += d * d;
    rest = Math.floor(rest / 10);
  }
  return sum;
}

function isHappy(n) {
  const seen = new Set();
  while (n !== 1 && !seen.has(n)) {
    seen.add(n);
    n = squareDigits(n);
  }
  return n === 1;
}

const chainFrom = (n, steps) => {
  const out = [n];
  for (let i = 0; i < steps && out.at(-1) !== 1; i++) out.push(squareDigits(out.at(-1)));
  return out;
};

const happyBelow50 = [];
for (let n = 1; n < 50; n++) if (isHappy(n)) happyBelow50.push(n);

const happyToHundred = [];
for (let n = 1; n <= 100; n++) if (isHappy(n)) happyToHundred.push(n);

// Every unhappy number below 500 passes through 4.
let allReachFour = true;
for (let n = 2; n < 500; n++) {
  if (isHappy(n)) continue;
  const seen = new Set();
  let m = n;
  let hitFour = false;
  while (!seen.has(m)) {
    seen.add(m);
    m = squareDigits(m);
    if (m === 4) hitFour = true;
  }
  if (!hitFour) allReachFour = false;
}

// Nothing can run away: four digits or more always shrinks.
let alwaysShrinks = true;
for (let n = 1000; n < 2000; n++) if (squareDigits(n) >= n) alwaysShrinks = false;

console.log('7 is happy   :', isHappy(7), chainFrom(7, 10));
console.log('4 is not     :', isHappy(4), chainFrom(4, 8));
console.log('happy below 50:', happyBelow50);
console.log('how many to 100:', happyToHundred.length);
console.log('squareDigits(9999):', squareDigits(9999), '<- far below 9999');

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
44const triangular = (n) => (n * (n + 1)) / 2;

const triangularByLoop = (n) => {
  let sum = 0;
  for (let k = 1; k <= n; k++) sum += k;
  return sum;
};

const isPerfectSquare = (n) => {
  const r = Math.round(Math.sqrt(n));
  return r * r === n;
};
const isTriangular = (t) => t >= 0 && isPerfectSquare(8 * t + 1);

// n terms starting at a, step d.
const arithmeticSum = (a, d, n) => (n * (2 * a + (n - 1) * d)) / 2;

// n terms starting at a, ratio r. r === 1 is not a special case of the formula.
const geometricSum = (a, r, n) => (r === 1 ? a * n : (a * (r ** n - 1)) / (r - 1));

const geometricByLoop = (a, r, n) => {
  let sum = 0;
  let term = a;
  for (let k = 0; k < n; k++) {
    sum += term;
    term *= r;
  }
  return sum;
};

let towardsTwo = 0;
let term = 1;
for (let k = 0; k < 100; k++) {
  towardsTwo += term;
  term /= 2;
}

console.log('first eight    :', [0, 1, 2, 3, 4, 5, 6, 7].map(triangular));
console.log('T(100), T(1000):', triangular(100), triangular(1000));
console.log('T(2e8)         :', triangular(200000000), 'safe?', Number.isSafeInteger(triangular(200000000)));
console.log('3, 8, 13, ... x 10:', arithmeticSum(3, 5, 10));
console.log('1 + 2 + 4 + ... :', geometricSum(1, 2, 10));
console.log('1 + 1/2 + ...   :', geometricSum(1, 0.5, 10), 'and 100 terms give', towardsTwo);
console.log('r === 1 unguarded:', (5 * (1 ** 4 - 1)) / (1 - 1));

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
55function fib(n) {
  let a = 0;
  let b = 1;
  for (let i = 0; i < n; i++) [a, b] = [b, a + b];
  return a;
}

// Same recurrence, exact, for checking where the double version drifts.
function fibExact(n) {
  let a = 0n;
  let b = 1n;
  for (let i = 0; i < n; i++) [a, b] = [b, a + b];
  return a;
}

let naiveCalls = 0;
function naiveFib(n) {
  naiveCalls++;
  return n < 2 ? n : naiveFib(n - 1) + naiveFib(n - 2);
}

let memoCalls = 0;
const memo = new Map();
function memoFib(n) {
  memoCalls++;
  if (n < 2) return n;
  if (memo.has(n)) return memo.get(n);
  const value = memoFib(n - 1) + memoFib(n - 2);
  memo.set(n, value);
  return value;
}

// Lucas: the same rule, seeded 2 and 1.
function lucas(n) {
  let a = 2;
  let b = 1;
  for (let i = 0; i < n; i++) [a, b] = [b, a + b];
  return a;
}

naiveCalls = 0;
const naive25 = naiveFib(25);
const naiveCost = naiveCalls;

memoCalls = 0;
const memo25 = memoFib(25);
const memoCost = memoCalls;

console.log('first twelve :', Array.from({ length: 12 }, (_, i) => fib(i)));
console.log('fib(50)      :', fib(50));
console.log('fib(78)      :', fib(78), 'safe?', Number.isSafeInteger(fib(78)));
console.log('fib(79)      :', fib(79), 'but exactly', fibExact(79).toString());
console.log('naive fib(25):', naive25, 'in', naiveCost, 'calls');
console.log('memoised     :', memo25, 'in', memoCost, 'calls');
console.log('lucas        :', Array.from({ length: 11 }, (_, i) => lucas(i)));

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
58function terms(n) {
  let count = 1;                       // the starting value is a term
  while (n !== 1) {
    n = n % 2 === 0 ? n / 2 : 3 * n + 1;
    count++;
  }
  return count;
}

const sequence = (n) => {
  const out = [n];
  while (out.at(-1) !== 1) {
    const last = out.at(-1);
    out.push(last % 2 === 0 ? last / 2 : 3 * last + 1);
  }
  return out;
};

const peak = (n) => {
  let highest = n;
  while (n !== 1) {
    n = n % 2 === 0 ? n / 2 : 3 * n + 1;
    if (n > highest) highest = n;
  }
  return highest;
};

// Cached: walk up to a known value, then fill in the path on the way back.
const cache = new Map([[1, 1]]);
function cachedTerms(n) {
  const path = [];
  let m = n;
  while (!cache.has(m)) {
    path.push(m);
    m = m % 2 === 0 ? m / 2 : 3 * m + 1;
  }
  let length = cache.get(m);
  while (path.length) cache.set(path.pop(), ++length);
  return cache.get(n);
}

let bestBelow1000 = { n: 1, terms: 1 };
for (let n = 1; n < 1000; n++) {
  const t = terms(n);
  if (t > bestBelow1000.terms) bestBelow1000 = { n, terms: t };
}

let bestTo10000 = { n: 1, terms: 1 };
for (let n = 1; n <= 10000; n++) {
  const t = cachedTerms(n);
  if (t > bestTo10000.terms) bestTo10000 = { n, terms: t };
}

console.log('sequence for 6 :', sequence(6));
console.log('terms for 27   :', terms(27), 'peaking at', peak(27));
console.log('longest < 1000 :', bestBelow1000);
console.log('longest <= 1e4 :', bestTo10000);
console.log('cache entries  :', cache.size, 'for a range of 10000');

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
30function factorial(n) {
  let product = 1;
  for (let k = 2; k <= n; k++) product *= k;
  return product;
}

function factorialExact(n) {
  let product = 1n;
  for (let k = 2n; k <= BigInt(n); k++) product *= k;
  return product;
}

const isExact = (n) => Number.isInteger(factorial(n)) && BigInt(factorial(n)) === factorialExact(n);

let lastSafe = 0;
while (Number.isSafeInteger(factorial(lastSafe + 1))) lastSafe++;

let lastExact = 0;
while (isExact(lastExact + 1)) lastExact++;

let lastFinite = 0;
while (Number.isFinite(factorial(lastFinite + 1))) lastFinite++;

console.log('0! to 5!    :', [0, 1, 2, 3, 4, 5].map(factorial));
console.log('10!         :', factorial(10));
console.log('last safe   :', lastSafe, factorial(lastSafe));
console.log('last exact  :', lastExact, factorial(lastExact));
console.log('23!         :', factorial(23), 'against', factorialExact(23).toString());
console.log('last finite :', lastFinite, factorial(lastFinite));
console.log('171!        :', factorial(171));

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
51const factorial = (n) => {
  let p = 1;
  for (let k = 2; k <= n; k++) p *= k;
  return p;
};

const chooseByFactorials = (n, k) => factorial(n) / (factorial(k) * factorial(n - k));

// Alternating multiply and divide: every intermediate is itself a C(m, i).
function choose(n, k) {
  if (k < 0 || k > n) return 0;
  k = Math.min(k, n - k);
  let result = 1;
  for (let i = 1; i <= k; i++) result = (result * (n - k + i)) / i;
  return result;
}

const permute = (n, k) => {
  if (k < 0 || k > n) return 0;
  let result = 1;
  for (let i = 0; i < k; i++) result *= n - i;
  return result;
};

// A row by running product, which drifts, ...
function rowByProduct(n) {
  const row = [1];
  for (let k = 0; k < n; k++) row.push((row[k] * (n - k)) / (k + 1));
  return row;
}

// ... and a row by addition, which does not.
function rowByAddition(n) {
  let row = [1];
  for (let i = 0; i < n; i++) {
    const next = [1];
    for (let j = 0; j < row.length - 1; j++) next.push(row[j] + row[j + 1]);
    next.push(1);
    row = next;
  }
  return row;
}

console.log('C(5, 2)        :', choose(5, 2));
console.log('C(52, 5)       :', choose(52, 5), 'P(52, 5):', permute(52, 5));
console.log('C(200, 100) via factorials:', chooseByFactorials(200, 100));
console.log('the same, multiplied out  :', choose(200, 100));
console.log('row 5          :', rowByProduct(5));
console.log('C(56, 28)      :', choose(56, 28));
console.log('row 56 at k=28 :', rowByProduct(56)[28], '<- one too many');
console.log('by addition    :', rowByAddition(56)[28]);

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16const sum = (xs) => xs.reduce((a, b) => a + b, 0);
const mean = (xs) => sum(xs) / xs.length;        // 0 / 0 when xs is empty

const marks = [72, 88, 61, 95, 79];

// The same three prices as floats, and as integer kobo.
const prices = [19.99, 25.5, 8.75];
const kobo = [1999, 2550, 875];

console.log('total          :', sum(marks));
console.log('mean           :', mean(marks));
console.log('mean of nothing:', mean([]), 'but the total of nothing is', sum([]));
console.log('with an outlier:', mean([...marks, 1000]));
console.log('float total    :', sum(prices));
console.log('kobo total     :', sum(kobo), '=', sum(kobo) / 100);
console.log('mean of tenths :', (0.1 + 0.2 + 0.3) / 3);

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19function median(xs) {
  const sorted = xs.slice().sort((a, b) => a - b);   // slice, or you reorder the caller's array
  const mid = Math.floor(sorted.length / 2);
  return sorted.length % 2 ? sorted[mid] : (sorted[mid - 1] + sorted[mid]) / 2;
}

const marks = [72, 88, 61, 95, 79];
const wide = [5, 40, 300, 1000];
const mean = (xs) => xs.reduce((a, b) => a + b, 0) / xs.length;

const caller = [3, 1, 2];
const answer = median(caller);

console.log('default sort   :', wide.slice().sort(), '<- strings');
console.log('numeric sort   :', wide.slice().sort((a, b) => a - b));
console.log('median of marks:', median(marks), 'and the mean is', mean(marks));
console.log('median of wide :', median(wide));
console.log('with an outlier:', median([...marks, 1000]), 'against a mean of', mean([...marks, 1000]));
console.log('caller after   :', caller, 'answer', answer);

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
28function tally(xs) {
  const counts = new Map();
  for (const x of xs) counts.set(x, (counts.get(x) ?? 0) + 1);
  return counts;
}

function modes(xs) {
  const counts = tally(xs);
  const top = Math.max(...counts.values());
  if (top === 1) return [];                       // nothing repeated
  return [...counts.keys()].filter((k) => counts.get(k) === top).sort((a, b) => a - b);
}

const sizes = [4, 7, 4, 9, 4, 7];
const tied = [1, 2, 2, 3, 3, 4];

// The same tally in a plain object, for comparison.
const asObject = {};
for (const x of [10, 2, 33, 2]) asObject[x] = (asObject[x] ?? 0) + 1;

const orders = ['yam', 'rice', 'yam'];

console.log('tally     :', [...tally(sizes)]);
console.log('mode      :', modes(sizes));
console.log('a tie     :', modes(tied));
console.log('no repeats:', modes([5, 6, 7]));
console.log('as object :', asObject, 'keys', Object.keys(asObject));
console.log('strings   :', [...tally(orders)]);

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16const range = (xs) => Math.max(...xs) - Math.min(...xs);

// No spread, so no argument limit.
const minOf = (xs) => xs.reduce((a, b) => (b < a ? b : a), Infinity);
const maxOf = (xs) => xs.reduce((a, b) => (b > a ? b : a), -Infinity);

const marks = [72, 88, 61, 95, 79];
const big = Array.from({ length: 100000 }, (_, i) => (i * 7919) % 100000);

console.log('min, max, range:', Math.min(...marks), Math.max(...marks), range(marks));
console.log('reduce agrees  :', minOf(marks), maxOf(marks));
console.log('no arguments   :', Math.min(), Math.max());
console.log('so empty range :', range([]));
console.log('one NaN        :', Math.min(...[1, NaN, 3]));
console.log('100000 values  :', minOf(big), maxOf(big));
console.log('0 and -0       :', Math.min(0, -0), 'which is minus zero:', Object.is(Math.min(0, -0), -0));

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23const mean = (xs) => xs.reduce((a, b) => a + b, 0) / xs.length;

const squaredDeviations = (xs) => {
  const m = mean(xs);
  return xs.reduce((acc, x) => acc + (x - m) ** 2, 0);
};

const variance = (xs, sample = false) =>
  squaredDeviations(xs) / (xs.length - (sample ? 1 : 0));
const sd = (xs, sample = false) => Math.sqrt(variance(xs, sample));

// One pass, no stored mean, and no accuracy either.
const naiveVariance = (xs) => mean(xs.map((x) => x * x)) - mean(xs) ** 2;

const data = [2, 4, 4, 4, 5, 5, 7, 9];
const offset = [1e9 + 1, 1e9 + 2, 1e9 + 3];   // spread of 2, sitting a billion out

console.log('mean, sum of squares:', mean(data), squaredDeviations(data));
console.log('population var, sd  :', variance(data), sd(data));
console.log('sample var, sd      :', variance(data, true), sd(data, true));
console.log('offset two-pass     :', variance(offset));
console.log('offset one-pass     :', naiveVariance(offset), '<- every digit gone');
console.log('constant list       :', sd([5, 5, 5]), 'sample sd of one value:', variance([5], true));

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
28function nearestRank(xs, p) {
  const a = xs.slice().sort((x, y) => x - y);
  if (p <= 0) return a[0];
  const rank = Math.ceil((p / 100) * a.length);        // 1-based
  return a[Math.min(rank, a.length) - 1];
}

function interpolated(xs, p) {
  const a = xs.slice().sort((x, y) => x - y);
  const i = ((a.length - 1) * p) / 100;                // 0-based, fractional
  const lo = Math.floor(i);
  const hi = Math.ceil(i);
  return lo === hi ? a[lo] : a[lo] + (i - lo) * (a[hi] - a[lo]);
}

const scores = [15, 20, 35, 40, 50];
const both = (p) => [nearestRank(scores, p), interpolated(scores, p)];

const q1 = interpolated(scores, 25);
const q3 = interpolated(scores, 75);

console.log('p30 :', both(30), '<- the two definitions disagree');
console.log('p40 :', both(40));
console.log('p50 :', both(50), 'and the median is 35');
console.log('p0, p100:', both(0), both(100));
console.log('quartiles:', q1, q3, 'IQR', q3 - q1);
console.log('p35 :', interpolated(scores, 35));
console.log('even count, p50:', interpolated([1, 2, 3, 4], 50));

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24function weightedMean(xs, ws) {
  let top = 0;
  let bottom = 0;
  for (let i = 0; i < xs.length; i++) {
    top += xs[i] * ws[i];
    bottom += ws[i];
  }
  return top / bottom;                    // divide by the weight total, not the count
}

const scores = [75, 62, 88];
const percent = [10, 30, 60];             // whole numbers, summing to 100
const decimal = [0.1, 0.3, 0.6];          // the same weights, as fractions
const raw = [1, 3, 6];                    // unnormalised, and it makes no difference

const plain = scores.reduce((a, b) => a + b, 0) / scores.length;

console.log('numerator      :', 10 * 75 + 30 * 62 + 60 * 88, 'over 100');
console.log('weighted grade :', weightedMean(scores, percent));
console.log('decimal weights:', weightedMean(scores, decimal), '<- one bit low');
console.log('raw weights    :', weightedMean(scores, raw));
console.log('unweighted mean:', plain);
console.log('equal weights  :', weightedMean(scores, [1, 1, 1]));
console.log('zero weights   :', weightedMean(scores, [0, 0, 0]));

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22function normalise(xs) {
  const lo = Math.min(...xs);
  const hi = Math.max(...xs);
  return xs.map((x) => (x - lo) / (hi - lo));       // 0 / 0 when hi === lo
}

const rescale = (xs, a, b) => normalise(xs).map((t) => a + t * (b - a));
const denormalise = (ts, lo, hi) => ts.map((t) => lo + t * (hi - lo));

const readings = [12, 40, 25, 60];
const flat = [7, 7, 7];

const unit = normalise(readings);
const round4 = (x) => Math.round(x * 10000) / 10000;

console.log('normalised :', unit);
console.log('to 4 places:', unit.map(round4));
console.log('ends       :', unit[0], unit[3]);
console.log('back again :', denormalise(unit, 12, 60));
console.log('to 20..80  :', rescale(readings, 20, 80));
console.log('as percent :', rescale(readings, 0, 100).map(round4));
console.log('flat list  :', normalise(flat));

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
26function cumulative(xs) {
  let total = 0;
  return xs.map((x) => (total += x));
}

const differences = (cs) => cs.map((c, i) => (i === 0 ? c : c - cs[i - 1]));

// A mean that never stores a total, so it cannot overflow one.
function runningMean(xs) {
  let m = 0;
  return xs.map((x, i) => (m += (x - m) / (i + 1)));
}

const sales = [5, 10, 15, 20];
const tenths = Array(10).fill(0.1);
const koboTenths = Array(10).fill(10);      // 10 kobo, ten times
const marks = [72, 88, 61, 95, 79];

const cum = cumulative(sales);

console.log('cumulative   :', cum);
console.log('differenced  :', differences(cum));
console.log('grand total  :', cum[cum.length - 1]);
console.log('ten tenths   :', cumulative(tenths));
console.log('in kobo      :', cumulative(koboTenths));
console.log('running mean :', runningMean(marks));

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20const n = 255;

let radixError = 'none';
try {
  n.toString(37);
} catch (e) {
  radixError = e.constructor.name;
}

const pattern = (-255 >>> 0).toString(2);     // the 32-bit two's complement bits
const tenth = (0.1).toString(2);

console.log('255 in 2, 8, 16, 36:', n.toString(2), n.toString(8), n.toString(16), n.toString(36));
console.log('default radix      :', n.toString(), 'same as String(n):', String(n));
console.log('-255 in binary     :', (-255).toString(2), '<- a sign, not two\'s complement');
console.log('the actual bits    :', pattern, 'which is', -255 >>> 0);
console.log('radix 37           :', radixError);
console.log('35 and 36 in base 36:', (35).toString(36), (36).toString(36));
console.log('0.1 in binary      :', tenth);
console.log('0.1 in hex         :', (0.1).toString(16));

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
42const DIGITS = '0123456789abcdefghijklmnopqrstuvwxyz';

function toBase(n, b) {
  if (n === 0) return '0';
  let rest = n;
  let out = '';
  while (rest > 0) {
    out = DIGITS[rest % b] + out;          // remainders come out backwards
    rest = Math.floor(rest / b);
  }
  return out;
}

// parseInt stops at the point, so a fractional part needs its own loop.
function fromBase(s, b) {
  const [whole, frac = ''] = s.split('.');
  let value = parseInt(whole, b);
  let scale = 1 / b;
  for (const ch of frac) {
    value += parseInt(ch, b) * scale;
    scale /= b;
  }
  return value;
}

const values = [0, 1, 7, 255, 4095, 99999];
const bases = [2, 3, 8, 16, 36];
const agrees = values.every((n) => bases.every((b) => toBase(n, b) === n.toString(b)));
const roundTrips = values.every((n) => bases.every((b) => parseInt(n.toString(b), b) === n));

const tenZ = parseInt('zzzzzzzzzz', 36);
const twelveZ = parseInt('zzzzzzzzzzzz', 36);
const overshoot = Number(BigInt(twelveZ) - (36n ** 12n - 1n));

console.log('by hand vs toString:', toBase(255, 16), (255).toString(16), agrees);
console.log('round trip         :', roundTrips);
console.log('parseInt at a point:', parseInt('1010.11', 2), 'but fromBase gives', fromBase('1010.11', 2));
console.log('0.1 through base 2 :', fromBase((0.1).toString(2), 2));
console.log('ten z in base 36   :', tenZ, Number.isSafeInteger(tenZ));
console.log('twelve z           :', twelveZ, 'true value 4738381338321616895');
console.log('overshoot          :', overshoot);
console.log('0b prefix          :', parseInt('0b1010', 2), 'but Number gives', Number('0b1010'));

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15const channels = [30, 9, 255];
const hex = (c) => c.toString(16).padStart(2, '0');
const colour = '#' + channels.map(hex).join('');
const unpadded = '#' + channels.map((c) => c.toString(16)).join('');

const byteBits = (n) => n.toString(2).padStart(8, '0');

console.log('0b11111111, 0o377, 0xff:', 0b11111111, 0o377, 0xff);
console.log('separators             :', 0b1010_1010, 1_000_000);
console.log('colour                 :', colour);
console.log('unpadded               :', unpadded, '<- five digits, a different colour');
console.log('uppercase              :', colour.toUpperCase());
console.log('bytes                  :', [5, 64, 255].map(byteBits));
console.log("Number('010')          :", Number('010'), "and parseInt('010', 8) is", parseInt('010', 8));
console.log('nine bits in an 8-pad  :', byteBits(511), byteBits(511).length);

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
27const READ = 1;
const WRITE = 2;
const EXEC = 4;

const grant = (perms, flag) => perms | flag;
const has = (perms, flag) => (perms & flag) !== 0;
const revoke = (perms, flag) => perms & ~flag;
const toggle = (perms, flag) => perms ^ flag;

const readWrite = grant(grant(0, READ), WRITE);      // 3
const all = grant(readWrite, EXEC);                  // 7

// XOR is its own inverse, which is what makes the swap work.
let a = 9;
let b = 4;
a ^= b;
b ^= a;
a ^= b;

console.log('12 & 10, 12 | 10, 12 ^ 10:', 12 & 10, 12 | 10, 12 ^ 10);
console.log('in binary                :', (12 & 10).toString(2), (12 | 10).toString(2), (12 ^ 10).toString(2));
console.log('~12, ~0, ~-1             :', ~12, ~0, ~-1);
console.log('permissions              :', readWrite, all, all.toString(2));
console.log('has WRITE, has EXEC      :', has(readWrite, WRITE), has(readWrite, EXEC));
console.log('revoke WRITE from 7      :', revoke(all, WRITE));
console.log('swapped without a temp   :', a, b);
console.log('5 & 3 against 5 && 3     :', 5 & 3, 5 && 3);

1
2
3
4
5
6
7
8
9
10
11const shiftLeft = (n, k) => n << k;
const half = (n) => n >> 1;

console.log('5 << 1, 5 << 3   :', 5 << 1, 5 << 3);
console.log('40 >> 3, 40 >>> 3:', 40 >> 3, 40 >>> 3);
console.log('3 << 30          :', 3 << 30, 'but 3 * 2 ** 30 is', 3 * 2 ** 30);
console.log('1 << 31          :', 1 << 31, '<- the sign bit');
console.log('1 << 32, 1 << 33 :', 1 << 32, 1 << 33, '<- count taken mod 32');
console.log('-8 >> 1, -8 >>> 1:', -8 >> 1, -8 >>> 1);
console.log('-1 >>> 0         :', -1 >>> 0, 'and back:', (-1 >>> 0) | 0);
console.log('-7 >> 1          :', -7 >> 1, 'against trunc', Math.trunc(-7 / 2), 'and floor', Math.floor(-7 / 2));

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
33function popcount(n) {
  let x = n;
  let count = 0;
  while (x) {                          // each pass clears one bit, so at most 32 passes
    x &= x - 1;
    count++;
  }
  return count;
}

const byString = (n) => [...n.toString(2)].filter((c) => c === '1').length;
const unsigned = (n) => byString(n >>> 0);

function bigPopcount(n) {
  let x = BigInt(n);
  let count = 0;
  while (x) {
    x &= x - 1n;
    count++;
  }
  return count;
}

const hamming = (a, b) => popcount(a ^ b);
const wide = 2 ** 53 - 1;              // 53 bits set, all of them

console.log('0, 1, 7, 255, 256, 1023:', [0, 1, 7, 255, 256, 1023].map(popcount));
console.log('-1                     :', popcount(-1), 'bits set');
console.log('by string, -1          :', byString(-1), '<- counting the wrong thing');
console.log('after >>> 0            :', unsigned(-1));
console.log('2 ** 53 - 1            :', popcount(wide), 'by loop,', byString(wide), 'by string');
console.log('as BigInt              :', bigPopcount(wide));
console.log('hamming(1011, 1101)    :', hamming(0b1011, 0b1101));

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
31const int32 = (x) => x | 0;
const uint32 = (x) => x >>> 0;

// A 32-bit hash, kept 32-bit on purpose.
function hash32(s) {
  let h = 0;
  for (let i = 0; i < s.length; i++) {
    h = (h << 5) - h + s.charCodeAt(i);     // h * 31 + code
    h |= 0;                                 // back into a signed 32-bit integer
  }
  return h;
}

// The same loop with the truncation left out.
function hashDrifting(s) {
  let h = 0;
  for (let i = 0; i < s.length; i++) h = (h << 5) - h + s.charCodeAt(i);
  return h;
}

const town = 'Abeokuta';

console.log('2 ** 31 | 0      :', int32(2 ** 31));
console.log('2 ** 32 + 5 | 0  :', int32(2 ** 32 + 5));
console.log('-1 >>> 0, back   :', uint32(-1), int32(uint32(-1)));
console.log('1.9 | 0, -1.9 | 0:', int32(1.9), int32(-1.9));
console.log('junk             :', [NaN, Infinity, '12abc', null, undefined].map(int32));
console.log('coercible        :', int32('12'), int32(true));
console.log('hash32           :', hash32(town), 'unsigned', uint32(hash32(town)));
console.log('without | 0      :', hashDrifting(town), 'which is', hashDrifting(town) - hash32(town), 'larger');
console.log('a negative hash  :', hash32('Ibadan'), '->', uint32(hash32('Ibadan')));

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15const area = (w, h) => w * h;
const perimeter = (w, h) => 2 * (w + h);
const diagonal = (w, h) => Math.hypot(w, h);

const w = 7.5;
const h = 4;

const side = perimeter(w, h) / 4;          // the square with the same perimeter

console.log('area, perimeter :', area(w, h), perimeter(w, h));
console.log('diagonal        :', diagonal(w, h), 'and 7.5 ** 2 + 4 ** 2 is', w ** 2 + h ** 2);
console.log('both sides x2   :', area(2 * w, 2 * h), perimeter(2 * w, 2 * h));
console.log('same perimeter  :', side, 'square area', area(side, side));
console.log('cm2 to m2       :', area(w, h) / 10000);
console.log('degenerate      :', area(w, 0), perimeter(w, 0));

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20const area = (r) => Math.PI * r ** 2;
const circumference = (r) => 2 * Math.PI * r;
const round3 = (x) => Math.round(x * 1000) / 1000;

const r = 3;
const sectorArea = (r, deg) => (area(r) * deg) / 360;
const arcLength = (r, deg) => (circumference(r) * deg) / 360;

// The same product, associated differently.
const wide = 2.8;
const squareFirst = Math.PI * wide ** 2;
const stepwise = Math.PI * wide * wide;

console.log('area, circumference:', area(r), circumference(r));
console.log('to three places    :', round3(area(r)), round3(circumference(r)));
console.log('from the diameter  :', (Math.PI * 6 ** 2) / 4);
console.log('60 degree sector   :', sectorArea(r, 60), 'arc', arcLength(r, 60));
console.log('r = 2.8, two ways  :', squareFirst, stepwise);
console.log('difference         :', stepwise - squareFirst);
console.log('22 / 7 against PI  :', 22 / 7, Math.abs(22 / 7 - Math.PI));

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
26const byBaseHeight = (base, height) => 0.5 * base * height;

const heron = (a, b, c) => {
  const s = (a + b + c) / 2;
  return Math.sqrt(s * (s - a) * (s - b) * (s - c));
};

// Kahan's rearrangement: sort descending, then group so nothing nearly cancels.
function stableHeron(a, b, c) {
  const [x, y, z] = [a, b, c].sort((p, q) => q - p);
  return Math.sqrt((x + (y + z)) * (z - (x - y)) * (z + (x - y)) * (x + (y - z))) / 4;
}

// A needle: two sides of a billion, one of a hundred-thousandth.
const needle = [1e9, 1e9, 1e-5];
const trueArea = 0.5 * 1e-5 * 1e9;          // base times height, to the last digit
const relativeError = (heron(...needle) - trueArea) / trueArea;

console.log('base 4, height 3 :', byBaseHeight(4, 3), 'Heron on 3-4-5:', heron(3, 4, 5));
console.log('7-8-9            :', heron(7, 8, 9), stableHeron(7, 8, 9));
console.log('equilateral, 2   :', heron(2, 2, 2), 'which is sqrt(3):', Math.sqrt(3));
console.log('1-2-3, degenerate:', heron(1, 2, 3));
console.log('1-2-10, no such  :', heron(1, 2, 10));
console.log('needle, Heron    :', heron(...needle));
console.log('needle, stable   :', stableHeron(...needle), 'true', trueArea);
console.log('relative error   :', relativeError);

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
29function signedArea(points) {
  let total = 0;
  for (let i = 0; i < points.length; i++) {
    const [x1, y1] = points[i];
    const [x2, y2] = points[(i + 1) % points.length];      // wraps to the first
    total += x1 * y2 - x2 * y1;
  }
  return total / 2;
}

const polygonArea = (points) => Math.abs(signedArea(points));

const trapeziumFormula = (a, b, h) => ((a + b) / 2) * h;

// Parallel sides 8 and 5, four units apart.
const trapezium = [[0, 0], [8, 0], [6, 4], [1, 4]];
const triangle = [[0, 0], [4, 0], [0, 3]];
const rectangle = [[0, 0], [7.5, 0], [7.5, 4], [0, 4]];
const pentagon = [[1, 1], [4, 1], [5, 3], [3, 5], [0, 3]];
const bowtie = [[0, 0], [1, 1], [1, 0], [0, 1]];

console.log('trapezium formula:', trapeziumFormula(8, 5, 4));
console.log('shoelace         :', polygonArea(trapezium));
console.log('signed, each way :', signedArea(trapezium), signedArea(trapezium.slice().reverse()));
console.log('triangle         :', polygonArea(triangle), 'Heron would give 6');
console.log('rectangle 7.5 x 4:', polygonArea(rectangle));
console.log('pentagon         :', polygonArea(pentagon));
console.log('collinear        :', polygonArea([[0, 0], [1, 1], [2, 2]]));
console.log('self-crossing    :', polygonArea(bowtie), '<- not a degenerate shape');

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16const cubeVolume = (s) => s ** 3;
const cubeSurface = (s) => 6 * s ** 2;

const cuboidVolume = (w, h, d) => w * h * d;
const cuboidSurface = (w, h, d) => 2 * (w * h + h * d + w * d);
const spaceDiagonal = (w, h, d) => Math.hypot(w, h, d);

const s = 3;

console.log('cube 3           :', cubeVolume(s), cubeSurface(s), spaceDiagonal(s, s, s));
console.log('that diagonal is :', s * Math.sqrt(3));
console.log('cuboid 2 x 3 x 6 :', cuboidVolume(2, 3, 6), cuboidSurface(2, 3, 6), spaceDiagonal(2, 3, 6));
console.log('side doubled     :', cubeVolume(6), cubeSurface(6));
console.log('ratios           :', cubeVolume(6) / cubeVolume(3), cubeSurface(6) / cubeSurface(3));
console.log('surface / volume :', cubeSurface(s) / cubeVolume(s), 'which is 6 / s');
console.log('unit cube        :', cubeVolume(1), cubeSurface(1));

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20const cylinderVolume = (r, h) => Math.PI * r ** 2 * h;
const cylinderLateral = (r, h) => 2 * Math.PI * r * h;
const cylinderSurface = (r, h) => 2 * Math.PI * r * (r + h);

const coneVolume = (r, h) => (Math.PI * r ** 2 * h) / 3;      // divide last
const coneVolumeThirdFirst = (r, h) => (1 / 3) * Math.PI * r ** 2 * h;
const slantHeight = (r, h) => Math.hypot(r, h);
const coneSurface = (r, h) => Math.PI * r * (r + slantHeight(r, h));

const r = 3;
const h = 10;

console.log('cylinder volume :', cylinderVolume(r, h));
console.log('lateral, total  :', cylinderLateral(r, h), cylinderSurface(r, h));
console.log('cone volume     :', coneVolume(r, h));
console.log('with 1/3 first  :', coneVolumeThirdFirst(r, h), '<- one bit lower');
console.log('three cones     :', 3 * coneVolume(r, h));
console.log('slant height    :', slantHeight(r, h), 'which is sqrt(109)');
console.log('cone surface    :', coneSurface(r, h));
console.log('radius doubled  :', cylinderVolume(6, h), 'over', cylinderVolume(3, h));

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22const volumeThirdFirst = (r) => (4 / 3) * Math.PI * r ** 3;
const volumeDivideLast = (r) => (4 * Math.PI * r ** 3) / 3;
const surface = (r) => 4 * Math.PI * r ** 2;
const hemisphereVolume = (r) => (2 / 3) * Math.PI * r ** 3;

const r = 6;

// The cylinder that just contains the sphere: same radius, height 2r.
const boundingCylinder = Math.PI * r ** 2 * (2 * r);

// dV/dr should be the surface area. Check it numerically.
const eps = 1e-6;
const derivative = (volumeThirdFirst(r + eps) - volumeThirdFirst(r - eps)) / (2 * eps);

console.log('volume, 4/3 first  :', volumeThirdFirst(r));
console.log('volume, divide last:', volumeDivideLast(r), '<- one bit higher');
console.log('surface            :', surface(r));
console.log('volume / surface   :', volumeThirdFirst(r) / surface(r), 'should be r / 3 =', r / 3);
console.log('hemisphere volume  :', hemisphereVolume(r), 'against the surface', surface(r));
console.log('difference         :', hemisphereVolume(r) - surface(r));
console.log('two thirds of cyl  :', (2 / 3) * boundingCylinder);
console.log('dV/dr              :', derivative);

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
27const distance = (p, q) => Math.hypot(q[0] - p[0], q[1] - p[1]);
const midpoint = (p, q) => [(p[0] + q[0]) / 2, (p[1] + q[1]) / 2];
const slope = (p, q) => (q[1] - p[1]) / (q[0] - p[0]);
const perpendicular = (m) => -1 / m;

// Collinear if the cross product of the two edge vectors is zero.
const cross = (p, q, r) => (q[0] - p[0]) * (r[1] - p[1]) - (q[1] - p[1]) * (r[0] - p[0]);
const collinearByCross = (p, q, r) => cross(p, q, r) === 0;
const collinearBySlope = (p, q, r) => slope(p, q) === slope(q, r);

const P = [2, 3];
const Q = [10, 9];
const M = midpoint(P, Q);

// Three points on one line, with coordinates that are not exact doubles.
const A = [0, 0];
const B = [0.1, 0.5];
const C = [0.4, 2];

console.log('distance   :', distance(P, Q));
console.log('midpoint   :', M, 'equidistant:', distance(P, M), distance(M, Q));
console.log('slope, perp:', slope(P, Q), perpendicular(slope(P, Q)));
console.log('vertical   :', slope([2, 3], [2, 9]), 'and downwards', slope([2, 9], [2, 3]));
console.log('same point :', slope(P, P));
console.log('horizontal :', slope([2, 3], [10, 3]));
console.log('two slopes :', slope(A, B), slope(B, C));
console.log('by slope   :', collinearBySlope(A, B, C), 'by cross product:', collinearByCross(A, B, C));