react-cheminfo 0.11.0 → 0.12.0

package/src/scatter/ui/scatterGroupSpread.ts

@@ -1,206 +0,0 @@
-/**
- * Every group's outline over every pair of axes, measured once.
- *
- * A pair grid asks the same question of a group thirty-six times, and calling
- * `confidenceEllipse` per cell would gather that group's points into a fresh
- * array of objects each time — n² allocations to draw n axes, over the same
- * samples. The averages and the pairwise covariances say everything an outline
- * needs, they come out of two passes over the scores read where they stand,
- * and a cell then reads four numbers out of the block.
- */
-
-import type { MatrixLike } from '../../chart/core/matrix.ts';
-import type {
-  ConfidenceEllipse,
-  EllipseCovariance,
-  EllipseSize,
-} from '../core/confidenceEllipse.ts';
-import {
-  ellipseAxes,
-  ellipseStandardDeviations,
-} from '../core/confidenceEllipse.ts';
-
-/** How every group is spread over the axes a grid lays out. */
-export interface ScatterGroupSpread {
-  /** How many leading axes each block covers. */
-  axes: number;
-  /** How many groups it holds. */
-  groups: number;
-  /** How many rows went into each group, in group order. */
-  counts: Int32Array;
-  /** Each group's average along each axis, at `group * axes + axis`. */
-  means: Float64Array;
-  /**
-   * How each group varies between two axes, at `(group * axes + a) * axes + b`
-   * and again at the transposed position, so a cell reads either way round.
-   */
-  covariances: Float64Array;
-  /** How far out an outline is drawn, in standard deviations. */
-  standardDeviations: number;
-  /** How many rows a group needs before it is outlined at all. */
-  minimumPoints: number;
-}
-
-/** How {@link scatterGroupSpread} measures the groups. */
-export interface ScatterGroupSpreadOptions {
-  /** The coordinates: one row per sample, one column per axis, read in place. */
-  scores: MatrixLike;
-  /** Which group each row belongs to; a row outside the range is left out. */
-  groupOf: ArrayLike<number>;
-  /** How many groups there are. */
-  groups: number;
-  /** How many leading axes to measure over. */
-  axes: number;
-  /**
-   * How large the outlines are drawn.
-   * @default { kind: 'coverage', probability: 0.95 }
-   */
-  size?: EllipseSize;
-  /**
-   * How many rows a group needs before it is outlined at all.
-   * @default 3
-   */
-  minimumPoints?: number;
-}
-
-/**
- * Measure every group over every laid-out axis, in two passes.
- *
- * A row missing a value in any one of the axes is left out of the group
- * altogether rather than only out of the cells that use that axis: an outline
- * that quietly covered a different set of samples in each cell would make the
- * grid disagree with itself, and a reader comparing two cells has no way to
- * see it. The spread uses the `n - 1` divisor, as `confidenceEllipse` does, so
- * a group outlined here and the same group outlined on the map come out the
- * same size.
- * @param options - See {@link ScatterGroupSpreadOptions}.
- * @returns The block, whose `counts` are what a caller reports as too small to outline.
- */
-export function scatterGroupSpread(
-  options: ScatterGroupSpreadOptions,
-): ScatterGroupSpread {
-  const { scores, groupOf, size = DEFAULT_SIZE, minimumPoints = 3 } = options;
-  const groups = Math.max(0, Math.trunc(options.groups));
-  const axes = Math.max(0, Math.min(Math.trunc(options.axes), scores.columns));
-  const counts = new Int32Array(groups);
-  const means = new Float64Array(groups * axes);
-  const covariances = new Float64Array(groups * axes * axes);
-  const spread: ScatterGroupSpread = {
-    axes,
-    groups,
-    counts,
-    means,
-    covariances,
-    standardDeviations: ellipseStandardDeviations(size),
-    minimumPoints,
-  };
-  if (groups === 0 || axes === 0) return spread;
-
-  for (let row = 0; row < scores.rows; row++) {
-    const group = groupAt(groupOf, row, groups);
-    if (group < 0 || !finiteRow(scores, row, axes)) continue;
-    counts[group] = (counts[group] ?? 0) + 1;
-    const base = group * axes;
-    for (let axis = 0; axis < axes; axis++) {
-      means[base + axis] = (means[base + axis] ?? 0) + scores.get(row, axis);
-    }
-  }
-  for (let group = 0; group < groups; group++) {
-    const count = counts[group] ?? 0;
-    if (count === 0) continue;
-    const base = group * axes;
-    for (let axis = 0; axis < axes; axis++) {
-      means[base + axis] = (means[base + axis] ?? 0) / count;
-    }
-  }
-
-  // One scratch row of deviations, reused for every sample: the alternative is
-  // reading each value twice per pair, which is axes² reads instead of axes.
-  const away = new Float64Array(axes);
-  for (let row = 0; row < scores.rows; row++) {
-    const group = groupAt(groupOf, row, groups);
-    if (group < 0 || !finiteRow(scores, row, axes)) continue;
-    const base = group * axes;
-    for (let axis = 0; axis < axes; axis++) {
-      away[axis] = scores.get(row, axis) - (means[base + axis] ?? 0);
-    }
-    const block = group * axes * axes;
-    for (let a = 0; a < axes; a++) {
-      const first = away[a] ?? 0;
-      for (let b = 0; b < axes; b++) {
-        const cell = block + a * axes + b;
-        covariances[cell] = (covariances[cell] ?? 0) + first * (away[b] ?? 0);
-      }
-    }
-  }
-  for (let group = 0; group < groups; group++) {
-    const divisor = (counts[group] ?? 0) - 1;
-    if (divisor < 1) continue;
-    const block = group * axes * axes;
-    for (let cell = 0; cell < axes * axes; cell++) {
-      covariances[block + cell] = (covariances[block + cell] ?? 0) / divisor;
-    }
-  }
-  return spread;
-}
-
-/**
- * One group's outline for one pair of axes, in data units.
- *
- * The two-by-two block cut out of the covariances is a covariance in its own
- * right — that is what makes the grid affordable — so it decomposes into
- * radii and a tilt exactly as a pair measured on its own would.
- * @param spread - The block, from {@link scatterGroupSpread}.
- * @param group - Which group.
- * @param xAxis - The axis along the foot of the cell.
- * @param yAxis - The axis up its side.
- * @returns The outline, or `null` when the group is too small to have a shape, when either axis is outside the block, or when the requested size is unbounded.
- */
-export function scatterPairEllipse(
-  spread: ScatterGroupSpread,
-  group: number,
-  xAxis: number,
-  yAxis: number,
-): ConfidenceEllipse | null {
-  const { axes, groups, counts, means, covariances } = spread;
-  const { minimumPoints, standardDeviations } = spread;
-  if (group < 0 || group >= groups) return null;
-  if (xAxis < 0 || yAxis < 0 || xAxis >= axes || yAxis >= axes) return null;
-  const count = counts[group] ?? 0;
-  if (count < Math.max(2, minimumPoints)) return null;
-
-  const base = group * axes;
-  const block = group * axes * axes;
-  const covariance: EllipseCovariance = {
-    xx: covariances[block + xAxis * axes + xAxis] ?? 0,
-    xy: covariances[block + xAxis * axes + yAxis] ?? 0,
-    yy: covariances[block + yAxis * axes + yAxis] ?? 0,
-  };
-  const { rx, ry, angle } = ellipseAxes(covariance, standardDeviations);
-  const cx = means[base + xAxis] ?? 0;
-  const cy = means[base + yAxis] ?? 0;
-  if (!Number.isFinite(rx) || !Number.isFinite(ry)) return null;
-  if (!Number.isFinite(cx) || !Number.isFinite(cy)) return null;
-  return { cx, cy, rx, ry, angle, count, covariance };
-}
-
-/** What a group is outlined at when the caller says nothing. */
-const DEFAULT_SIZE: EllipseSize = { kind: 'coverage', probability: 0.95 };
-
-function groupAt(
-  groupOf: ArrayLike<number>,
-  row: number,
-  groups: number,
-): number {
-  const raw = groupOf[row];
-  if (raw === undefined || !Number.isFinite(raw)) return -1;
-  const group = Math.trunc(raw);
-  return group < 0 || group >= groups ? -1 : group;
-}
-
-function finiteRow(scores: MatrixLike, row: number, axes: number): boolean {
-  for (let axis = 0; axis < axes; axis++) {
-    if (!Number.isFinite(scores.get(row, axis))) return false;
-  }
-  return true;
-}

package/src/scatter3d/ui/CloudPointLayer.tsx

@@ -1,132 +0,0 @@
-import type { ReactElement } from 'react';
-import { memo } from 'react';
-
-import type { ScreenPoints } from '../../scatter/core/screenPoints.ts';
-import { depthFraction } from '../core/orbitCamera.ts';
-
-/** What {@link CloudPointLayer} draws. */
-export interface CloudPointLayerProps {
-  /** Where every sample sits, in the figure's pixels. */
-  points: ScreenPoints;
-  /** How far towards the reader each one is, in cube units. */
-  depths: Float64Array;
-  /** The rows, furthest first, which is the order they are painted in. */
-  order: Uint32Array;
-  /**
-   * Which group each sample belongs to, as an index into `colors`. An entry of
-   * `-1`, or one outside the range, is a sample in no group.
-   * @default undefined — every sample is one crowd
-   */
-  groupOf?: ArrayLike<number>;
-  /**
-   * The colour of each group, in group order.
-   * @default undefined — every sample takes `fallbackColor`
-   */
-  colors?: readonly string[];
-  /**
-   * How strongly each group is drawn, in the same order.
-   * @default undefined — every group is drawn at full strength
-   */
-  opacities?: readonly number[];
-  /**
-   * Colour of a sample belonging to no group.
-   * @default 'var(--text-faint)'
-   */
-  fallbackColor?: string;
-  /**
-   * Radius of a dot at the middle of the cube, in pixels. A dot at the front
-   * is drawn larger and one at the back smaller, about this.
-   * @default 3.5
-   */
-  radius?: number;
-  /**
-   * The index from which samples are drawn as outlines rather than filled,
-   * which is how one the model was fitted on is told from one placed into it
-   * afterwards.
-   * @default undefined — every sample is filled
-   */
-  outlinedFrom?: number;
-}
-
-/**
- * Every sample as one dot, painted from the back of the box forwards.
- *
- * Two things carry the depth, and neither costs an event handler: the order,
- * so a dot in front covers one behind it, and the size, so a dot at the front
- * of the box is a fifth larger than the same dot at the back. Both are read
- * from the projection rather than from the data, so a turn changes them and a
- * filter does not.
- *
- * Like the flat cloud's own layer, this one carries no handler and no closure
- * per dot: every gesture lands on one transparent rectangle above it and is
- * answered from a coordinate array.
- * @param props - See {@link CloudPointLayerProps}.
- * @returns The cloud.
- */
-export const CloudPointLayer = memo(function CloudPointLayer(
-  props: CloudPointLayerProps,
-): ReactElement {
-  const { points, depths, order, groupOf, colors, opacities } = props;
-  const { fallbackColor = 'var(--text-faint)', radius = 3.5 } = props;
-  const { outlinedFrom } = props;
-
-  const xs = points.x;
-  const ys = points.y;
-  const count = Math.min(xs.length, ys.length, order.length);
-  const hollowFrom = outlineStart(outlinedFrom, count);
-
-  const dots: ReactElement[] = [];
-  for (let step = 0; step < count; step++) {
-    const index = order[step] as number;
-    const x = xs[index];
-    const y = ys[index];
-    if (x === undefined || y === undefined) continue;
-    if (!Number.isFinite(x) || !Number.isFinite(y)) continue;
-    const group = groupOf?.[index] ?? -1;
-    const color = colors?.[group] ?? fallbackColor;
-    const alpha = opacities?.[group] ?? 1;
-    const hollow = index >= hollowFrom;
-    dots.push(
-      <circle
-        key={index}
-        cx={round(x)}
-        cy={round(y)}
-        r={round(radius * depthScale(depths[index] as number))}
-        fill={hollow ? 'none' : color}
-        stroke={hollow ? color : undefined}
-        strokeWidth={hollow ? OUTLINE_WIDTH : undefined}
-        opacity={alpha === 1 ? undefined : alpha}
-      />,
-    );
-  }
-
-  return <g data-layer="points">{dots}</g>;
-});
-
-/**
- * How much larger a dot is drawn for sitting near the front of the box.
- *
- * A fifth from back to front. Enough that the eye reads it as depth when it is
- * looking for depth, and little enough that nobody mistakes it for a value:
- * a dot size that carried a measurement would be a fourth dimension nothing
- * labelled.
- * @param depth - How far towards the reader the sample is, in cube units.
- * @returns The factor to draw its radius at.
- */
-function depthScale(depth: number): number {
-  return 0.9 + DEPTH_RANGE * depthFraction(depth);
-}
-
-function outlineStart(outlinedFrom: number | undefined, count: number): number {
-  if (outlinedFrom === undefined || !Number.isFinite(outlinedFrom)) {
-    return count;
-  }
-  return Math.max(0, Math.floor(outlinedFrom));
-}
-
-const DEPTH_RANGE = 0.4;
-
-/** The same weight the flat cloud draws a hollow dot at, so the two read alike. */
-const OUTLINE_WIDTH = 1.5;
-
-const round = (value: number): number => Math.round(value * 100) / 100;

package/src/spectra/ui/matrixSteps.ts

@@ -1,128 +0,0 @@
-import type { MatrixFilter, MatrixFilterName } from '../core/settings.ts';
-import { MATRIX_FILTER_NAMES } from '../core/settingsProblems.ts';
-
-/** One editable option of a matrix step. */
-export interface MatrixOptionField {
-  /** Which key it sits under in the step's options. */
-  key: string;
-  /** What the field is called. */
-  label: string;
-  /**
-   * What upstream does when it is left empty.
-   * @default undefined — the field carries no placeholder
-   */
-  placeholder?: string;
-}
-
-/** What the editor knows about one matrix step. */
-export interface MatrixStep {
-  /** What it is called in the list. */
-  label: string;
-  /** One line saying what it does to the matrix. */
-  summary: string;
-  /** Its editable options, empty when it takes none. */
-  fields: readonly MatrixOptionField[];
-}
-
-/**
- * What the editor knows about the three steps the matrix stage dispatches.
- *
- * Keyed by the name rather than listed, so a name the processor's own switch
- * does not match cannot reach the menu: an unknown name is the one way this
- * stage throws.
- */
-export const MATRIX_STEPS: Readonly<Record<MatrixFilterName, MatrixStep>> = {
-  pqn: {
-    label: 'Probabilistic quotient normalization',
-    summary:
-      'Divides every spectrum by its own dilution factor, read against the median spectrum. Min is declared upstream but never read.',
-    fields: [
-      { key: 'min', label: 'Min' },
-      { key: 'max', label: 'Max', placeholder: '100' },
-    ],
-  },
-  centerMean: {
-    label: 'Centre on the mean',
-    summary:
-      'Subtracts the mean of every column. It takes no options: anything set here is ignored.',
-    fields: [],
-  },
-  rescale: {
-    label: 'Rescale',
-    summary: 'Brings the whole matrix between two values.',
-    fields: [
-      { key: 'min', label: 'Min', placeholder: '0' },
-      { key: 'max', label: 'Max', placeholder: '1' },
-    ],
-  },
-};
-
-/** The add menu: the empty prompt, then the only three names that run. */
-export const MATRIX_ADD_OPTIONS: ReadonlyArray<{
-  value: string;
-  label: string;
-}> = [
-  { value: '', label: 'Add a matrix step…' },
-  ...MATRIX_FILTER_NAMES.map((name) => ({
-    value: name,
-    label: MATRIX_STEPS[name].label,
-  })),
-];
-
-/**
- * What the editor knows about a step, when it knows it at all.
- * @param name - The name the settings hold.
- * @returns Its entry, or undefined for a name the processor would throw on.
- */
-export function matrixStep(name: string | undefined): MatrixStep | undefined {
-  if (name === undefined) return undefined;
-  return Object.hasOwn(MATRIX_STEPS, name)
-    ? MATRIX_STEPS[name as MatrixFilterName]
-    : undefined;
-}
-
-/**
- * What one option of a step is set to.
- * @param step - The step.
- * @param key - Which option to read.
- * @returns The number, or undefined when the step leaves it to upstream.
- */
-export function readMatrixOption(
-  step: MatrixFilter,
-  key: string,
-): number | undefined {
-  const options: unknown = step.options;
-  if (typeof options !== 'object' || options === null) return undefined;
-  const held = (options as Record<string, unknown>)[key];
-  return typeof held === 'number' ? held : undefined;
-}
-
-/**
- * The step with one option set, or dropped when the box was emptied.
- *
- * Dropping rather than writing `undefined` is what lets a cleared box mean
- * "whatever upstream does", which is the only way back to the default once a
- * reader has typed over it.
- * @param step - The step.
- * @param key - Which option to write.
- * @param value - What to set it to, or undefined to clear it.
- * @returns A new step.
- */
-export function writeMatrixOption(
-  step: MatrixFilter,
-  key: string,
-  value: number | undefined,
-): MatrixFilter {
-  const held: unknown = step.options;
-  const source: Record<string, unknown> =
-    typeof held === 'object' && held !== null
-      ? (held as Record<string, unknown>)
-      : {};
-  const options: Record<string, unknown> = {};
-  for (const [name, option] of Object.entries(source)) {
-    if (name !== key) options[name] = option;
-  }
-  if (value !== undefined) options[key] = value;
-  if (Object.keys(options).length === 0) return { name: step.name };
-  return { name: step.name, options };
-}

package/src/state/ui/index.ts

@@ -1,6 +0,0 @@
-export type {
-  BucketRead,
-  PersistBucketOptions,
-  PersistedBucket,
-} from './persistBucket.ts';
-export { persistBucket } from './persistBucket.ts';