react-cheminfo 0.2.0 → 0.4.0

package/src/orbital/core/grid.ts

@@ -0,0 +1,126 @@
+/**
+ * Sampling a wavefunction onto a dense scalar field for the isosurface renderer.
+ *
+ * The memory order is a hard contract with molstar: `Tensor.Space([nx, ny, nz],
+ * [0, 1, 2])` reads `dataOffset = x·ny·nz + y·nz + z`, so **z varies fastest**.
+ * The loops below are written in exactly that order and
+ * {@link gridIndex} is the single place the arithmetic is spelled out.
+ */
+
+import type { Vec3 } from './constants.ts';
+
+/** An axis-aligned sampling box, ångström. */
+export interface GridBox {
+  /** Lowest corner. */
+  origin: Vec3;
+  /** Edge lengths along x, y and z. */
+  size: Vec3;
+}
+
+/**
+ * A wavefunction, sampled at one point.
+ * @param x - Offset from the origin along x, ångström.
+ * @param y - Offset along y.
+ * @param z - Offset along z.
+ * @returns The amplitude, Å^(-3/2).
+ */
+export type OrbitalEvaluator = (x: number, y: number, z: number) => number;
+
+/** A sampled scalar field plus the statistics an isovalue is chosen from. */
+export interface OrbitalGrid {
+  /** `nx·ny·nz` samples, z varying fastest. */
+  data: Float32Array;
+  /** `[nx, ny, nz]`. */
+  dimensions: [number, number, number];
+  /** Position of sample `(0, 0, 0)`, ångström. */
+  origin: Vec3;
+  /** Distance between neighbouring samples on every axis, ångström. */
+  spacing: number;
+  min: number;
+  max: number;
+  mean: number;
+  /** Population standard deviation of the samples. */
+  sigma: number;
+}
+
+/**
+ * Sample a wavefunction over a box.
+ * @param evaluate - the wavefunction, cartesian ångström in, amplitude out.
+ * @param box - the region to cover.
+ * @param resolution - samples along the longest edge; the spacing it implies is
+ * used on all three axes, so the voxels stay cubic.
+ * @returns the field, its layout and its single-pass statistics.
+ * @throws {Error} when `resolution` is below 2 or the box has no volume.
+ */
+export function evaluateGrid(
+  evaluate: OrbitalEvaluator,
+  box: GridBox,
+  resolution: number,
+): OrbitalGrid {
+  if (resolution < 2) {
+    throw new Error('a grid needs at least 2 samples per axis');
+  }
+  const { origin, size } = box;
+  const longestEdge = Math.max(size.x, size.y, size.z);
+  if (!(longestEdge > 0)) {
+    throw new Error('the sampling box must have a non-zero edge');
+  }
+  const spacing = longestEdge / (resolution - 1);
+  const countX = axisCount(size.x, spacing);
+  const countY = axisCount(size.y, spacing);
+  const countZ = axisCount(size.z, spacing);
+  const data = new Float32Array(countX * countY * countZ);
+  let min = Infinity;
+  let max = -Infinity;
+  let sum = 0;
+  let sumSquares = 0;
+  let index = 0;
+  for (let indexX = 0; indexX < countX; indexX++) {
+    const x = origin.x + indexX * spacing;
+    for (let indexY = 0; indexY < countY; indexY++) {
+      const y = origin.y + indexY * spacing;
+      for (let indexZ = 0; indexZ < countZ; indexZ++) {
+        const value = Math.fround(evaluate(x, y, origin.z + indexZ * spacing));
+        data[index++] = value;
+        if (value < min) min = value;
+        if (value > max) max = value;
+        sum += value;
+        sumSquares += value * value;
+      }
+    }
+  }
+  const count = data.length;
+  const mean = sum / count;
+  const variance = sumSquares / count - mean * mean;
+  return {
+    data,
+    dimensions: [countX, countY, countZ],
+    origin: { x: origin.x, y: origin.y, z: origin.z },
+    spacing,
+    min,
+    max,
+    mean,
+    sigma: Math.sqrt(Math.max(variance, 0)),
+  };
+}
+
+/**
+ * Flat offset of a sample, the layout molstar expects.
+ * @param dimensions - `[nx, ny, nz]` of the grid.
+ * @param indexX - sample index along x.
+ * @param indexY - sample index along y.
+ * @param indexZ - sample index along z, the fastest-varying axis.
+ * @returns the index into {@link OrbitalGrid.data}.
+ */
+export function gridIndex(
+  dimensions: [number, number, number],
+  indexX: number,
+  indexY: number,
+  indexZ: number,
+): number {
+  return (indexX * dimensions[1] + indexY) * dimensions[2] + indexZ;
+}
+
+function axisCount(edge: number, spacing: number): number {
+  return Math.max(2, Math.round(edge / spacing) + 1);
+}

package/src/orbital/core/hydrogenic.ts

@@ -0,0 +1,222 @@
+/**
+ * Hydrogen-like atomic orbitals: the exact one-electron solutions, scaled to an
+ * element by an effective nuclear charge.
+ *
+ * `R(r) = N (2Zr/na₀)^ℓ e^(−Zr/na₀) L^(2ℓ+1)_(n−ℓ−1)(2Zr/na₀)`
+ *
+ * The associated Laguerre polynomial is the whole point. The Slater orbital a
+ * hybridisation model uses is `r^(n−1) e^(−ζr)`, which is **nodeless**: it draws
+ * a 2s exactly like a 1s, only fatter. That is fine for a hybrid lobe, where
+ * only the outer contour is ever seen, and wrong for a picture whose subject is
+ * what an orbital looks like — `n − ℓ − 1` radial nodes and ℓ angular ones is
+ * the first thing a student is asked to count.
+ *
+ * Amplitudes are in Å^(-3/2) and distances in ångström, like everything else
+ * here, so `∫|ψ|² dV` over a grid measured in ångström is 1.
+ */
+
+import { BOHR_IN_ANGSTROM, RYDBERG_ELECTRONVOLTS } from './constants.ts';
+import {
+  assertQuantumNumbers,
+  bisectRoot,
+  factorial,
+  laguerre,
+} from './numerics.ts';
+
+/** Which hydrogen-like orbital, and how strongly it is bound. */
+export interface HydrogenicParameters {
+  /** Principal quantum number, 1 and up. */
+  n: number;
+  /** Angular momentum quantum number, 0 to n − 1. */
+  l: number;
+  /** Effective nuclear charge, in units of the elementary charge. */
+  charge: number;
+}
+
+/**
+ * Radial nodes: spheres on which the wavefunction vanishes and changes sign.
+ * @param parameters - Which orbital.
+ * @returns `n − ℓ − 1`.
+ */
+export function radialNodeCount(parameters: HydrogenicParameters): number {
+  return parameters.n - parameters.l - 1;
+}
+
+/**
+ * Mean distance of the electron from the nucleus,
+ * `⟨r⟩ = a₀(3n² − ℓ(ℓ+1)) / 2Z`.
+ * @param parameters - Which orbital.
+ * @returns The expectation value in ångström.
+ */
+export function meanRadius(parameters: HydrogenicParameters): number {
+  const { n, l, charge } = parameters;
+  return (
+    (BOHR_IN_ANGSTROM * (3 * n * n - l * (l + 1))) /
+    (2 * Math.max(charge, 1e-6))
+  );
+}
+
+/**
+ * Orbital energy in the hydrogen-like model, `E = −13.6 Z²/n²` eV.
+ * @param parameters - Which orbital.
+ * @returns The energy in electronvolts, always negative.
+ */
+export function orbitalEnergy(parameters: HydrogenicParameters): number {
+  const { n, charge } = parameters;
+  return (-RYDBERG_ELECTRONVOLTS * charge * charge) / (n * n);
+}
+
+/**
+ * Build the radial function `R(r)`, with every constant hoisted out so a grid
+ * sweep pays for the exponential and the polynomial only.
+ * @param parameters - Which orbital.
+ * @returns A function taking a distance in ångström and returning Å^(-3/2).
+ * @throws {Error} When the quantum numbers are not a real orbital, i.e. `n < 1` or
+ * `ℓ` outside `0 … n − 1`, or when the charge is not positive.
+ */
+export function createRadialFunction(
+  parameters: HydrogenicParameters,
+): (distance: number) => number {
+  const { n, l, charge } = parameters;
+  assertQuantumNumbers(n, l);
+  if (!(charge > 0)) {
+    throw new RangeError(
+      `the effective charge must be positive, got ${charge}`,
+    );
+  }
+  const degree = n - l - 1;
+  const alpha = 2 * l + 1;
+  // ρ = 2Zr/(n a₀), with r in ångström, so a₀ appears once here and never again.
+  const rho = (2 * charge) / (n * BOHR_IN_ANGSTROM);
+  const normalisation = Math.sqrt(
+    rho * rho * rho * (factorial(degree) / (2 * n * factorial(n + l))),
+  );
+  return (distance) => {
+    const scaled = rho * distance;
+    return (
+      normalisation *
+      scaled ** l *
+      Math.exp(-scaled / 2) *
+      laguerre(degree, alpha, scaled)
+    );
+  };
+}
+
+/**
+ * Evaluate the radial function once.
+ * @param parameters - Which orbital.
+ * @param distance - Distance from the nucleus, ångström.
+ * @returns The radial amplitude, Å^(-3/2).
+ */
+export function radialAmplitude(
+  parameters: HydrogenicParameters,
+  distance: number,
+): number {
+  return createRadialFunction(parameters)(distance);
+}
+
+/**
+ * Where the radial nodes actually are.
+ *
+ * The `n − ℓ − 1` roots are bracketed by scanning outwards and then bisected,
+ * rather than solved for, because the Laguerre roots have no closed form past
+ * the quadratic and a bisection on a function we already evaluate cannot drift
+ * out of step with what is drawn.
+ * @param parameters - Which orbital.
+ * @param limit - Distance to search out to, ångström. Defaults to a box that
+ * comfortably holds the outermost node.
+ * @returns The node radii in ångström, ascending; empty for a nodeless orbital.
+ */
+export function radialNodeRadii(
+  parameters: HydrogenicParameters,
+  limit = meanRadius(parameters) * 3,
+): number[] {
+  const expected = radialNodeCount(parameters);
+  if (expected === 0) return [];
+  const radial = createRadialFunction(parameters);
+  const radii: number[] = [];
+  const steps = 4000;
+  let previousDistance = 1e-6;
+  let previous = radial(previousDistance);
+  for (let step = 1; step <= steps; step++) {
+    const distance = (limit * step) / steps;
+    const value = radial(distance);
+    if (previous === 0 || previous < 0 !== value < 0) {
+      radii.push(bisectRoot(radial, previousDistance, distance));
+      if (radii.length === expected) break;
+    }
+    previousDistance = distance;
+    previous = value;
+  }
+  return radii;
+}
+
+/**
+ * Smallest sphere holding a given share of the electron.
+ *
+ * Used to size the sampling box: too small clips the orbital at a face, too
+ * large wastes the grid on empty space, and both are visible on screen.
+ * @param parameters - Which orbital.
+ * @param fraction - Share of `∫ r²R² dr` to enclose, between 0 and 1.
+ * @returns The radius in ångström.
+ * @throws {Error} When `fraction` is outside `(0, 1)`.
+ */
+export function enclosingRadius(
+  parameters: HydrogenicParameters,
+  fraction: number,
+): number {
+  if (!(fraction > 0) || fraction >= 1) {
+    throw new RangeError(`the enclosed fraction must be in (0, 1)`);
+  }
+  const radial = createRadialFunction(parameters);
+  // The tail decays as e^(−2Zr/n a₀); ten mean radii is far past every node.
+  const limit = meanRadius(parameters) * 10;
+  const steps = 4000;
+  const step = limit / steps;
+  const weights = new Float64Array(steps + 1);
+  let total = 0;
+  for (let index = 0; index <= steps; index++) {
+    const distance = index * step;
+    const value = radial(distance);
+    const weight = value * value * distance * distance;
+    weights[index] = weight;
+    total += weight;
+  }
+  if (total === 0) return limit;
+  let running = 0;
+  const target = total * fraction;
+  for (let index = 0; index <= steps; index++) {
+    running += weights[index] as number;
+    if (running >= target) return index * step;
+  }
+  return limit;
+}
+
+/**
+ * Sample the radial distribution `P(r) = r²R(r)²` — the curve whose zeroes are
+ * the radial nodes and whose area is the electron.
+ * @param parameters - Which orbital.
+ * @param limit - Distance to sample out to, ångström.
+ * @param count - Number of samples, at least 2.
+ * @returns Distances and the amplitude `R`, plus `P`, at each of them.
+ * @throws {Error} When `count` is below 2.
+ */
+export function radialProfile(
+  parameters: HydrogenicParameters,
+  limit: number,
+  count: number,
+): { distances: Float64Array; amplitude: Float64Array; density: Float64Array } {
+  if (count < 2) throw new RangeError('a radial profile needs 2 samples');
+  const radial = createRadialFunction(parameters);
+  const distances = new Float64Array(count);
+  const amplitude = new Float64Array(count);
+  const density = new Float64Array(count);
+  for (let index = 0; index < count; index++) {
+    const distance = (limit * index) / (count - 1);
+    const value = radial(distance);
+    distances[index] = distance;
+    amplitude[index] = value;
+    density[index] = value * value * distance * distance;
+  }
+  return { distances, amplitude, density };
+}

package/src/orbital/core/index.ts

@@ -0,0 +1,63 @@
+export type { ResolutionLimits } from './atomicGrid.ts';
+export { atomicGridResolution } from './atomicGrid.ts';
+export type { AtomicOrbital, AtomicOrbitalOptions } from './atomicOrbitals.ts';
+export {
+  atomicOrbitalsOf,
+  defaultOrbitalId,
+  findAtomicOrbital,
+  hydrogenicParametersOf,
+} from './atomicOrbitals.ts';
+export type { Vec3 } from './constants.ts';
+export { BOHR_IN_ANGSTROM, RYDBERG_ELECTRONVOLTS } from './constants.ts';
+export type { Subshell, SubshellOccupancy } from './electronConfiguration.ts';
+export {
+  ELEMENT_ANOMALIES,
+  HIGHEST_ATOMIC_NUMBER,
+  MADELUNG_ORDER,
+  NOBLE_GASES,
+  aufbauConfigurationOf,
+  configurationOf,
+  coreAtomicNumber,
+  formatConfiguration,
+  formatOccupancy,
+  isAnomalous,
+  subshellCapacity,
+  subshellLabel,
+} from './electronConfiguration.ts';
+export type { GridBox, OrbitalEvaluator, OrbitalGrid } from './grid.ts';
+export { evaluateGrid, gridIndex } from './grid.ts';
+export type { OrbitalContour } from './isovalue.ts';
+export { enclosedReach, isocontourCutoff, orbitalContour } from './isovalue.ts';
+export type { HydrogenicParameters } from './hydrogenic.ts';
+export {
+  createRadialFunction,
+  enclosingRadius,
+  meanRadius,
+  orbitalEnergy,
+  radialAmplitude,
+  radialNodeCount,
+  radialNodeRadii,
+  radialProfile,
+} from './hydrogenic.ts';
+export {
+  hundDistribution,
+  outermostShell,
+  withoutOutermostElectron,
+} from './occupancy.ts';
+export type { PhasePalette, PhasePaletteId } from './palette.ts';
+export { DEFAULT_PHASE_PALETTE_ID, PHASE_PALETTES } from './palette.ts';
+export type { RealHarmonic } from './realHarmonics.ts';
+export {
+  REAL_HARMONICS,
+  SUBSHELL_LETTERS,
+  harmonicsOf,
+  subshellLetter,
+} from './realHarmonics.ts';
+export type {
+  AtomicSampleRequest,
+  AtomicSampleResult,
+  AtomicSampler,
+} from './sample.ts';
+export { runAtomicSample } from './sample.ts';
+export type { Screening } from './screening.ts';
+export { slaterScreening } from './screening.ts';

package/src/orbital/core/isovalue.ts

@@ -0,0 +1,146 @@
+/**
+ * Choosing the value a signed wavefunction's isosurface is drawn at.
+ *
+ * The surface is named by how much of the electron it holds, not by an
+ * amplitude: `ENCLOSED_WEIGHT` of `∫|ψ|² dV` inside it and the tail
+ * outside. On a uniform grid that is a weighted quantile of the samples, and
+ * the isovalue is the `|ψ|` at which the quantile falls.
+ *
+ * molstar ships `computeOrbitalIsocontourValues` for the same job, and it
+ * cannot be used here. It abandons any field whose mean `ψ²` is under an
+ * absolute `1e-5` and returns no isovalue at all — a guard against degenerate
+ * data that instead reads the amplitude *scale*. Amplitudes are Å^(-3/2), so a
+ * diffuse orbital is normalised straight into that range and draws nothing:
+ * caesium's 6s reaches 13 Å, and 2588 of the 7460 orbitals lcao.cheminfo.org
+ * offers came back blank. A quantile has no scale of its own and cannot.
+ *
+ * Every pass below touches each of the million-odd samples, so all of them are
+ * indexed loops: `for…of` over a `Float32Array` measures 6.7× slower.
+ */
+
+import { ENCLOSED_WEIGHT } from './constants.ts';
+import type { OrbitalGrid } from './grid.ts';
+
+/**
+ * The `|ψ|` whose surface encloses a given share of the sampled electron.
+ * @param data - The sampled amplitudes.
+ * @param enclosedWeight - Share of `∑ψ²` to hold inside, between 0 and 1.
+ * @returns The isovalue, or 0 when the field is empty — a nodeless orbital
+ * sampled where it has no amplitude at all.
+ * @throws {Error} When `enclosedWeight` is outside `(0, 1)`.
+ */
+export function isocontourCutoff(
+  data: Float32Array,
+  enclosedWeight: number = ENCLOSED_WEIGHT,
+): number {
+  if (!(enclosedWeight > 0) || enclosedWeight >= 1) {
+    throw new RangeError('the enclosed weight must be in (0, 1)');
+  }
+  let total = 0;
+  let peak = 0;
+  for (let index = data.length - 1; index >= 0; index--) {
+    const value = data[index] as number;
+    const weight = value * value;
+    total += weight;
+    if (weight > peak) peak = weight;
+  }
+  if (!(total > 0)) return 0;
+
+  // Bins are logarithmic because a wavefunction spans decades between its peak
+  // and its tail while the isovalue sits far below the peak: linear bins would
+  // drop every sample that decides the answer into the first one.
+  const bins = new Float64Array(BIN_COUNT);
+  const peakLogarithm = Math.log2(peak);
+  for (let index = data.length - 1; index >= 0; index--) {
+    const value = data[index] as number;
+    const weight = value * value;
+    if (weight === 0) continue;
+    const bin = Math.floor(
+      (peakLogarithm - Math.log2(weight)) * BINS_PER_OCTAVE,
+    );
+    const clamped = bin < 0 ? 0 : Math.min(bin, BIN_COUNT - 1);
+    bins[clamped] = (bins[clamped] as number) + weight;
+  }
+
+  const target = total * enclosedWeight;
+  let running = 0;
+  for (let bin = 0; bin < BIN_COUNT; bin++) {
+    running += bins[bin] as number;
+    // Everything above this bin's lower edge is what has just been counted.
+    if (running >= target) {
+      return Math.sqrt(peak * 2 ** (-(bin + 1) / BINS_PER_OCTAVE));
+    }
+  }
+  return 0;
+}
+
+/**
+ * How far from the centre of the box the drawn surface actually reaches.
+ *
+ * Molstar sizes a volume representation's bounding sphere from the whole
+ * sampled box, which is deliberately larger than the isosurface inside it, so a
+ * camera framing that sphere leaves the orbital a quarter of the frame wide.
+ * Measuring the samples that are really enclosed gives the camera the extent it
+ * has to fill.
+ * @param field - The sampled field.
+ * @param cutoff - The isovalue the surfaces are drawn at.
+ * @returns The reach in ångström, or 0 when nothing is enclosed.
+ */
+export function enclosedReach(field: OrbitalGrid, cutoff: number): number {
+  if (!(cutoff > 0)) return 0;
+  const { data, dimensions, origin, spacing } = field;
+  const [countX, countY, countZ] = dimensions;
+  const centreX = origin.x + ((countX - 1) * spacing) / 2;
+  const centreY = origin.y + ((countY - 1) * spacing) / 2;
+  const centreZ = origin.z + ((countZ - 1) * spacing) / 2;
+  let furthest = 0;
+  let index = 0;
+  for (let indexX = 0; indexX < countX; indexX++) {
+    const dx = origin.x + indexX * spacing - centreX;
+    for (let indexY = 0; indexY < countY; indexY++) {
+      const dy = origin.y + indexY * spacing - centreY;
+      for (let indexZ = 0; indexZ < countZ; indexZ++) {
+        const value = data[index++] as number;
+        if (value < cutoff && value > -cutoff) continue;
+        const dz = origin.z + indexZ * spacing - centreZ;
+        const squared = dx * dx + dy * dy + dz * dz;
+        if (squared > furthest) furthest = squared;
+      }
+    }
+  }
+  return Math.sqrt(furthest);
+}
+
+/** Which isovalue each phase is drawn at, and how far the pair reaches. */
+export interface OrbitalContour {
+  /** `|ψ|` on the surface; 0 when there is nothing to draw. */
+  cutoff: number;
+  /** Distance from the centre of the box to the outermost enclosed sample. */
+  reach: number;
+}
+
+/**
+ * The isovalue and the extent of one sampled orbital's surface pair.
+ *
+ * Both phases come from one cutoff, so they can never disagree about where the
+ * node between them is.
+ * @param field - The sampled field.
+ * @param enclosedWeight - Share of `∑ψ²` to hold inside.
+ * @returns See {@link OrbitalContour}.
+ */
+export function orbitalContour(
+  field: OrbitalGrid,
+  enclosedWeight: number = ENCLOSED_WEIGHT,
+): OrbitalContour {
+  const cutoff = isocontourCutoff(field.data, enclosedWeight);
+  return { cutoff, reach: enclosedReach(field, cutoff) };
+}
+
+/**
+ * Bins per doubling of `ψ²`, so the isovalue lands within 2.2% in `|ψ|`.
+ * Finer than the grid spacing can resolve on the surface it produces.
+ */
+const BINS_PER_OCTAVE = 16;
+
+/** 128 octaves of `ψ²`, far past the dynamic range of a sampled orbital. */
+const BIN_COUNT = 2048;

package/src/orbital/core/numerics.ts

@@ -0,0 +1,79 @@
+/**
+ * The numerical machinery the radial functions are built on.
+ *
+ * Kept apart from `hydrogenic.ts` so that file reads as the physics it is —
+ * `R(r)`, `⟨r⟩`, the nodes, the enclosing sphere — with none of it buried under
+ * a polynomial recurrence and a bisection.
+ */
+
+/**
+ * The generalised Laguerre polynomial `L^α_k(x)`, by its three-term recurrence.
+ *
+ * The closed form overflows well before `n = 7`; `k` is at most 6 here.
+ * @param degree - Degree `k` of the polynomial.
+ * @param alpha - Order `α` of the polynomial.
+ * @param x - Where to evaluate it.
+ * @returns The value of the polynomial.
+ */
+export function laguerre(degree: number, alpha: number, x: number): number {
+  if (degree === 0) return 1;
+  let previous = 1;
+  let current = 1 + alpha - x;
+  for (let index = 1; index < degree; index++) {
+    const next =
+      ((2 * index + 1 + alpha - x) * current - (index + alpha) * previous) /
+      (index + 1);
+    previous = current;
+    current = next;
+  }
+  return current;
+}
+
+/**
+ * The root of a function inside a bracket it already changes sign over.
+ * @param radial - The function to find a zero of.
+ * @param low - Lower end of the bracket.
+ * @param high - Upper end.
+ * @returns The root, to about a picometre.
+ */
+export function bisectRoot(
+  radial: (distance: number) => number,
+  low: number,
+  high: number,
+): number {
+  let left = low;
+  let right = high;
+  const leftSign = radial(left) < 0;
+  for (let step = 0; step < 60 && right - left > 1e-9; step++) {
+    const middle = (left + right) / 2;
+    if (radial(middle) < 0 === leftSign) left = middle;
+    else right = middle;
+  }
+  return (left + right) / 2;
+}
+
+/**
+ * Reject quantum numbers that are not a real orbital.
+ * @param n - Principal quantum number.
+ * @param l - Angular momentum quantum number.
+ * @throws {RangeError} When `n < 1`, or ℓ is outside `0 … n − 1`.
+ */
+export function assertQuantumNumbers(n: number, l: number): void {
+  if (!Number.isInteger(n) || n < 1) {
+    throw new RangeError(`the principal quantum number must be 1 or more`);
+  }
+  if (!Number.isInteger(l) || l < 0 || l >= n) {
+    throw new RangeError(`ℓ must be between 0 and ${n - 1} for n = ${n}`);
+  }
+}
+
+/**
+ * The factorial of a small non-negative integer.
+ * @param value - The integer.
+ * @returns Its factorial.
+ */
+export function factorial(value: number): number {
+  let result = 1;
+  for (let index = 2; index <= value; index++) result *= index;
+  return result;
+}