react-cheminfo 0.11.0 → 0.13.0

package/src/periodic/core/layout.ts

@@ -16,13 +16,17 @@ import { PERIODIC_ELEMENTS, elementBySymbol } from './elements.ts';
 
 /** A whole run of the table: one group, or one period. */
 export interface ElementRange {
+  /** Whether the run is a group or a period. */
   kind: 'group' | 'period';
+  /** Its number: a group from 1 to 18, a period from 1 to 7. */
   value: number;
 }
 
 /** A cell of the grid, one-based as CSS grid lines are. */
 export interface Cell {
+  /** Grid column, one-based. */
   column: number;
+  /** Grid row, one-based. */
   row: number;
 }
 
@@ -64,7 +68,7 @@ export function placedElements(): ReadonlyArray<{
   element: PeriodicElement;
   cell: Cell;
 }> {
-  PLACED ??= PERIODIC_ELEMENTS.map((element) => ({
+  placedCache ??= PERIODIC_ELEMENTS.map((element) => ({
     element,
     cell: cellOf(element),
   })).toSorted((first, second) =>
@@ -72,11 +76,13 @@ export function placedElements(): ReadonlyArray<{
       ? first.cell.column - second.cell.column
       : first.cell.row - second.cell.row,
   );
-  return PLACED;
+  return placedCache;
 }
 
-let PLACED: ReadonlyArray<{ element: PeriodicElement; cell: Cell }> | null =
-  null;
+let placedCache: ReadonlyArray<{
+  element: PeriodicElement;
+  cell: Cell;
+}> | null = null;
 
 /**
  * The two cells the lanthanoids and the actinoids were lifted out of.
@@ -145,25 +151,25 @@ const ARROW_DIRECTIONS: Record<string, { column: number; row: number }> = {
 };
 
 function readingOrderIndex(): Map<string, number> {
-  READING_ORDER ??= new Map(
+  readingOrderCache ??= new Map(
     placedElements().map(({ element }, index) => [element.symbol, index]),
   );
-  return READING_ORDER;
+  return readingOrderCache;
 }
 
-let READING_ORDER: Map<string, number> | null = null;
+let readingOrderCache: Map<string, number> | null = null;
 
 function byCell(): Map<string, PeriodicElement> {
-  BY_CELL ??= new Map(
+  cellIndexCache ??= new Map(
     placedElements().map(({ element, cell }) => [
       cellKey(cell.column, cell.row),
       element,
     ]),
   );
-  return BY_CELL;
+  return cellIndexCache;
 }
 
-let BY_CELL: Map<string, PeriodicElement> | null = null;
+let cellIndexCache: Map<string, PeriodicElement> | null = null;
 
 function cellKey(column: number, row: number): string {
   return `${String(column)}:${String(row)}`;

package/src/periodic/ui/CategoryLegend.tsx

@@ -4,6 +4,7 @@
 
 import type { CSSProperties, ReactElement } from 'react';
 
+import { TOKEN } from '../../tokens/core/familyTokens.ts';
 import {
   CATEGORY_LABELS,
   CATEGORY_ORDER,
@@ -24,6 +25,11 @@ export interface CategoryLegendProps {
    * @default undefined — none is
    */
   selected?: ElementCategory;
+  /**
+   * Class names added to the root element.
+   * @default undefined
+   */
+  className?: string;
 }
 
 /**
@@ -32,10 +38,10 @@ export interface CategoryLegendProps {
  * @returns The legend.
  */
 export function CategoryLegend(props: CategoryLegendProps): ReactElement {
-  const { onSelect, selected } = props;
+  const { className, onSelect, selected } = props;
 
   return (
-    <div style={legendStyle}>
+    <div className={className} style={legendStyle}>
       {CATEGORY_ORDER.map((category) => {
         const swatch = categorySwatch(category);
         const label = CATEGORY_LABELS[category];
@@ -74,7 +80,7 @@ export function CategoryLegend(props: CategoryLegendProps): ReactElement {
 }
 
 const legendStyle = {
-  color: 'var(--text-muted, rgb(95 107 124))',
+  color: TOKEN.textMuted,
   display: 'flex',
   flexWrap: 'wrap',
   fontSize: 11,

package/src/periodic/ui/ElementCell.tsx

@@ -8,7 +8,7 @@
 
 import type { CSSProperties, ReactElement } from 'react';
 
-import type { Swatch } from '../../color/core/scale.ts';
+import type { Swatch } from '../../color/core/interpolate.ts';
 
 /** What {@link ElementCell} needs to draw one element. */
 export interface ElementCellProps {
@@ -24,6 +24,7 @@ export interface ElementCellProps {
   column: number;
   /** Row of the grid, one-based. */
   row: number;
+  /** Called with the symbol when the cell is chosen. */
   onSelect: (symbol: string) => void;
   /**
    * Third line, under the symbol: the value the tool is showing.
@@ -46,6 +47,11 @@ export interface ElementCellProps {
    * @default undefined
    */
   onHover?: (symbol: string | null) => void;
+  /**
+   * Class names added to the root element.
+   * @default undefined
+   */
+  className?: string;
 }
 
 /**
@@ -55,6 +61,7 @@ export interface ElementCellProps {
  */
 export function ElementCell(props: ElementCellProps): ReactElement {
   const {
+    className,
     atomicNumber,
     symbol,
     name,
@@ -71,6 +78,7 @@ export function ElementCell(props: ElementCellProps): ReactElement {
   return (
     <button
       type="button"
+      className={className}
       data-testid={`element-${symbol}`}
       data-symbol={symbol}
       aria-label={`${name} (${symbol}, Z = ${String(atomicNumber)})`}

package/src/periodic/ui/PeriodicTable.tsx

@@ -13,7 +13,7 @@
 import type { CSSProperties, KeyboardEvent, ReactElement } from 'react';
 import { useEffect, useRef } from 'react';
 
-import type { Swatch } from '../../color/core/scale.ts';
+import type { Swatch } from '../../color/core/interpolate.ts';
 import { categorySwatch } from '../core/categories.ts';
 import type { PeriodicElement } from '../core/elements.ts';
 import type { ElementRange } from '../core/layout.ts';
@@ -88,7 +88,8 @@ export interface PeriodicTableProps {
    */
   markers?: boolean;
   /**
-   * Whether the arrow keys walk the table by atomic number.
+   * Whether the arrow keys walk the grid: down from carbon is silicon, and
+   * right from the end of a period is the start of the next.
    * @default true
    */
   keyboard?: boolean;
@@ -97,6 +98,11 @@ export interface PeriodicTableProps {
    * @default undefined
    */
   onHover?: (symbol: string | null) => void;
+  /**
+   * Class of the outermost element.
+   * @default undefined
+   */
+  className?: string;
 }
 
 /**
@@ -118,6 +124,7 @@ export function PeriodicTable(props: PeriodicTableProps): ReactElement {
     markers = true,
     keyboard = true,
     onHover,
+    className,
   } = props;
 
   const gridRef = useRef<HTMLDivElement>(null);
@@ -144,7 +151,7 @@ export function PeriodicTable(props: PeriodicTableProps): ReactElement {
   }
 
   return (
-    <div style={rootStyle}>
+    <div className={className} style={rootStyle}>
       <div
         ref={gridRef}
         role="grid"

package/src/periodic/ui/PeriodicTableChrome.tsx

@@ -5,6 +5,7 @@
 
 import type { CSSProperties, ReactElement } from 'react';
 
+import { TOKEN } from '../../tokens/core/familyTokens.ts';
 import type { ElementRange } from '../core/layout.ts';
 import {
   COLUMN_COUNT,
@@ -13,7 +14,7 @@ import {
 } from '../core/layout.ts';
 
 /** What {@link HeaderStrips} needs. */
-export interface HeaderStripsProps {
+interface HeaderStripsProps {
   /**
    * Called with the run whose header was clicked. Without it the strips are
    * labels rather than buttons.
@@ -86,7 +87,7 @@ export function HeaderStrips(props: HeaderStripsProps): ReactElement {
 }
 
 /** What {@link InnerTransitionMarkers} needs. */
-export interface InnerTransitionMarkersProps {
+interface InnerTransitionMarkersProps {
   /** 1 when the table draws its header strips, 0 otherwise. */
   offset: number;
 }
@@ -145,7 +146,7 @@ function HeaderCell(props: HeaderCellProps): ReactElement {
 
 const headerStyle = {
   alignItems: 'center',
-  color: 'var(--text-muted, rgb(95 107 124))',
+  color: TOKEN.textMuted,
   display: 'flex',
   fontSize: 'clamp(0.4rem, 1.9cqw, 0.62rem)',
   justifyContent: 'center',
@@ -161,9 +162,9 @@ const headerButtonStyle = {
 
 const markerStyle = {
   alignItems: 'center',
-  border: '1px dashed rgb(182 191 204)',
+  border: `1px dashed ${TOKEN.borderStrong}`,
   borderRadius: 3,
-  color: 'var(--text-muted, rgb(95 107 124))',
+  color: TOKEN.textMuted,
   display: 'flex',
   fontSize: 'clamp(0.36rem, 1.7cqw, 0.55rem)',
   justifyContent: 'center',

package/src/projection/core/explainedShares.ts

@@ -6,7 +6,7 @@ import type { ProjectionAxis } from './projectionResult.ts';
 export interface ComponentShare {
   /** The number written on the axis, counting from one. */
   number: number;
-  /** What it is called, e.g. `PC 3`. */
+  /** What it is called, e.g. `PC3`. */
   label: string;
   /** Its colour, the same one it carries on every other tab. */
   color: string;

package/src/projection/core/fillCopy.ts

@@ -0,0 +1,21 @@
+/**
+ * A sentence with its placeholders filled in.
+ *
+ * The placeholders are `{name}`, and one with no value is left in place rather
+ * than replaced by an empty string, so a site that mistypes a key sees the
+ * mistake in the figure instead of a sentence that quietly loses a number.
+ * @param template - The sentence, from the projection copy.
+ * @param values - What each placeholder stands for.
+ * @returns The filled sentence.
+ */
+export function fillCopy(
+  template: string,
+  values: Readonly<Record<string, string>>,
+): string {
+  return template.replaceAll(PLACEHOLDER, (match: string, name: string) => {
+    const value = values[name];
+    return value === undefined ? match : value;
+  });
+}
+
+const PLACEHOLDER = /\{(?<name>[^{}]+)\}/gu;

package/src/projection/core/index.ts

@@ -27,15 +27,12 @@ export type {
   LoadingProfilesOptions,
 } from './loadingProfiles.ts';
 export { loadingProfiles } from './loadingProfiles.ts';
-export type { PcaLike } from './pcaLike.ts';
+export { fillCopy } from './fillCopy.ts';
+export type { PcaLike, PcaModelRecord } from './pcaLike.ts';
 export type { PcaResultOptions } from './pcaResult.ts';
 export { pcaResult } from './pcaResult.ts';
 export type { ProjectionCopy } from './projectionCopy.ts';
-export {
-  PROJECTION_COPY,
-  fillCopy,
-  mergeProjectionCopy,
-} from './projectionCopy.ts';
+export { PROJECTION_COPY } from './projectionCopy.ts';
 export type { ProjectionCopyPatch } from './projectionCopyPatch.ts';
 export type {
   ProjectionColorBy,
@@ -43,10 +40,14 @@ export type {
   ProjectionOptions,
   ProjectionVariablesView,
 } from './projectionOptions.ts';
-export {
-  DEFAULT_PROJECTION_OPTIONS,
-  resolveProjectionOptions,
-} from './projectionOptions.ts';
+export { mergeProjectionCopy } from './mergeProjectionCopy.ts';
+export { DEFAULT_PROJECTION_OPTIONS } from './projectionOptions.ts';
+export type {
+  ProjectionChoiceWords,
+  ProjectionOutlineWords,
+  ProjectionPanelWords,
+  ProjectionReasonWords,
+} from './projectionPanelWords.ts';
 export type {
   ProjectionAxis,
   ProjectionLoadings,
@@ -67,6 +68,7 @@ export type {
 export { PROJECTION_HELP } from './projectionStrings.ts';
 export type { ProjectionTab } from './projectionTabs.ts';
 export { projectionTabs } from './projectionTabs.ts';
+export { resolveProjectionOptions } from './resolveProjectionOptions.ts';
 export type {
   ContinuousVariableAxis,
   NamedVariableAxis,

package/src/projection/core/loadingProfiles.ts

@@ -13,7 +13,7 @@ import { drawableVariablesView } from './variablesView.ts';
 export interface LoadingProfile {
   /** Which component, from 0. */
   index: number;
-  /** What the panel is titled, e.g. `PC 2`. */
+  /** What the panel is titled, e.g. `PC2`. */
   label: string;
   /** The colour this component carries on every tab. */
   color: string;
@@ -81,6 +81,12 @@ export interface LoadingProfilesOptions {
    * @default ''
    */
   sampleLabel?: string;
+  /**
+   * What the vertical axis measures while the panels draw weights, which are a
+   * share of a direction rather than a quantity anybody measured.
+   * @default 'Weight'
+   */
+  weightLabel?: string;
 }
 
 /**
@@ -105,6 +111,7 @@ export function loadingProfiles(
     order,
     view: wanted,
     sampleScores,
+    weightLabel = 'Weight',
   } = options;
   const {
     weights,
@@ -165,7 +172,7 @@ export function loadingProfiles(
     const axis = axes[index];
     profiles.push({
       index,
-      label: axis?.name ?? `Component ${index + 1}`,
+      label: axis?.name ?? '',
       color: chartSeriesColor(index, 'component'),
       share: axis?.share,
       values,
@@ -190,8 +197,7 @@ export function loadingProfiles(
     order: slots,
     mean: reference,
     profiles,
-    // Weights are a share of a direction, not a quantity anybody measured.
-    valueLabel: view === 'weights' ? 'Weight' : valueLabel,
+    valueLabel: view === 'weights' ? weightLabel : valueLabel,
     sharedScale,
     // Bars are read from the zero line, so the line has to be on the panel; a
     // spectrum sitting on a baseline would be squashed into its top third by

package/src/projection/core/mergeProjectionCopy.ts

@@ -0,0 +1,39 @@
+import type { ProjectionCopy } from './projectionCopy.ts';
+import { PROJECTION_COPY } from './projectionCopy.ts';
+import type { ProjectionCopyPatch } from './projectionCopyPatch.ts';
+
+/**
+ * The words the viewer will write, with a site's overrides merged in one key
+ * at a time, so a site fixing a single sentence keeps every other default.
+ * @param overrides - What the site wants said differently.
+ * @returns Every word, complete.
+ */
+export function mergeProjectionCopy(
+  overrides?: ProjectionCopyPatch<ProjectionCopy>,
+): ProjectionCopy {
+  if (overrides === undefined) return { ...PROJECTION_COPY };
+  return mergeBranch(
+    PROJECTION_COPY as unknown as Branch,
+    overrides,
+  ) as unknown as ProjectionCopy;
+}
+
+type Branch = Record<string, unknown>;
+
+function mergeBranch(base: Branch, overrides: Branch): Branch {
+  const merged: Branch = { ...base };
+  for (const key of Object.keys(overrides)) {
+    const value = overrides[key];
+    if (value === undefined) continue;
+    const current = merged[key];
+    merged[key] =
+      isBranch(current) && isBranch(value)
+        ? mergeBranch(current, value)
+        : value;
+  }
+  return merged;
+}
+
+function isBranch(value: unknown): value is Branch {
+  return typeof value === 'object' && value !== null && !Array.isArray(value);
+}

package/src/projection/core/pcaColumns.ts

@@ -0,0 +1,84 @@
+import type { MatrixLike } from '../../chart/core/matrix.ts';
+
+/**
+ * The average and the spread of every measurement, read off the rows in place.
+ * @param rows - The measurements, one array per sample.
+ * @param width - How many measurements each row must carry.
+ * @returns The average and the sample standard deviation of each column.
+ * @throws {Error} When a row is not `width` wide or a measurement is not a finite number.
+ */
+export function columnStats(
+  rows: readonly number[][],
+  width: number,
+): { mean: number[]; deviation: number[] } {
+  // Centred on the average so far, in one pass: a running total of the raw
+  // values squared loses the low bits of a spectrum sitting on a baseline.
+  // `deviation` carries the squared spread until the last loop roots it.
+  const mean = new Array<number>(width).fill(0);
+  const deviation = new Array<number>(width).fill(0);
+  for (let index = 0; index < rows.length; index++) {
+    const row = rows[index];
+    if (row?.length !== width) {
+      throw new Error(
+        `pcaResult was given a row ${row?.length ?? 0} measurements wide at index ${index}, where the first row is ${width} wide.`,
+      );
+    }
+    const seen = index + 1;
+    for (let column = 0; column < width; column++) {
+      const value = row[column];
+      if (value === undefined || !Number.isFinite(value)) {
+        throw new Error(
+          `pcaResult was given ${String(value)} at row ${index}, measurement ${column}. A model carries it on into a map of nothing at all.`,
+        );
+      }
+      const before = mean[column] ?? 0;
+      const step = value - before;
+      const after = before + step / seen;
+      mean[column] = after;
+      deviation[column] = (deviation[column] ?? 0) + step * (value - after);
+    }
+  }
+
+  const divisor = Math.max(1, rows.length - 1);
+  for (let column = 0; column < width; column++) {
+    deviation[column] = Math.sqrt((deviation[column] ?? 0) / divisor);
+  }
+  return { mean, deviation };
+}
+
+/**
+ * The loadings with a column of zero weight put back wherever the model
+ * dropped a measurement that never moved.
+ * @param loadings - The model's loadings, one column per measurement it kept.
+ * @param excluded - The dropped columns, each a position in what was left.
+ * @param width - How many measurements a row carries.
+ * @returns Loadings as wide as a row, or the model's own when nothing was
+ * dropped or the record does not add up.
+ */
+export function widenedLoadings(
+  loadings: MatrixLike,
+  excluded: readonly number[],
+  width: number,
+): MatrixLike {
+  if (excluded.length === 0) return loadings;
+  const kept: number[] = [];
+  for (let column = 0; column < width; column++) kept.push(column);
+  for (const position of excluded) kept.splice(position, 1);
+  if (kept.length !== loadings.columns) return loadings;
+
+  const keptAt = new Int32Array(width).fill(DROPPED);
+  for (let index = 0; index < kept.length; index++) {
+    keptAt[kept[index] ?? 0] = index;
+  }
+  return {
+    rows: loadings.rows,
+    columns: width,
+    get: (row: number, column: number) => {
+      if (column < 0 || column >= width) return Number.NaN;
+      const at = keptAt[column] ?? DROPPED;
+      return at === DROPPED ? 0 : loadings.get(row, at);
+    },
+  };
+}
+
+const DROPPED = -1;

package/src/projection/core/pcaLike.ts

@@ -1,14 +1,32 @@
 import type { MatrixLike } from '../../chart/core/matrix.ts';
 
+/**
+ * What a fitted model says about how it was fitted: the two facts the viewer
+ * cannot recover from the loadings alone.
+ */
+export interface PcaModelRecord {
+  /**
+   * Whether each measurement was divided by its spread before fitting.
+   * @default undefined — the model does not say
+   */
+  scale?: boolean;
+  /**
+   * The columns dropped because they never moved, as `ml-pca` records them:
+   * each one a position in the columns left after the ones before it were
+   * removed.
+   * @default undefined — nothing was dropped
+   */
+  excludedFeatures?: readonly number[];
+}
+
 /**
  * A fitted principal component analysis, described structurally so that
  * nothing in this package imports `ml-pca`.
  *
  * `ml-pca`'s `PCA` satisfies it as it stands, with no adapter and no cast.
- * `getEigenvectors`, `getStandardDeviations`, `invert` and `toJSON` are
- * deliberately absent: nothing here needs them, and `getEigenvectors` hands
- * out the model's live internal matrix, which a component library must never
- * be given.
+ * `getEigenvectors`, `getStandardDeviations` and `invert` are deliberately
+ * absent: nothing here needs them, and `getEigenvectors` hands out the model's
+ * live internal matrix, which a component library must never be given.
  */
 export interface PcaLike {
   /**
@@ -30,4 +48,12 @@ export interface PcaLike {
   getEigenvalues: () => number[];
   /** Row `i` is component `i`, column `j` is original measurement `j`. */
   getLoadings: () => MatrixLike;
+  /**
+   * The model's own record of how it was fitted. Only `scale` and
+   * `excludedFeatures` are read; the matrices `ml-pca` puts beside them are
+   * never touched.
+   * @default undefined — the caller's `scaled` is trusted, and a model whose
+   * loadings are narrower than the rows is refused
+   */
+  toJSON?: () => PcaModelRecord;
 }

package/src/projection/core/pcaResult.ts

@@ -1,6 +1,7 @@
 import type { MatrixLike } from '../../chart/core/matrix.ts';
 import { mappedMatrix, stackedMatrix } from '../../chart/core/matrix.ts';
 
+import { columnStats, widenedLoadings } from './pcaColumns.ts';
 import type { PcaLike } from './pcaLike.ts';
 import type { ProjectionAxis, ProjectionResult } from './projectionResult.ts';
 import type { VariableAxis } from './variableAxis.ts';
@@ -41,8 +42,9 @@ export interface PcaResultOptions {
   scores?: MatrixLike;
   /**
    * Whether the model divided each measurement by its spread — the `scale`
-   * given to `new PCA(...)`. It cannot be read back from the model's public
-   * surface, and getting it wrong offers a view that is the same drawing
+   * given to `new PCA(...)`. A model that reports it through `toJSON`, as
+   * `ml-pca`'s does, is believed instead, so this is read only for a model
+   * that does not. Getting it wrong offers a view that is the same drawing
    * twice.
    * @default false
    */
@@ -82,9 +84,11 @@ export interface PcaResultOptions {
  * @returns The result, with every tab's data filled in.
  * @throws {Error} When `rows` is empty, when a row's length differs from the
  * first row's, when a measurement is not a finite number, or when the model's
- * loadings are not as wide as a row — which is what happens when the model was
- * fitted with `ignoreZeroVariance` and silently dropped a column, and which
- * would otherwise label every loadings panel one measurement out.
+ * loadings are not as wide as a row and the model does not report which
+ * columns it dropped — which is what `ignoreZeroVariance` leaves behind, and
+ * which would otherwise label every loadings panel one measurement out. A
+ * model that does report them keeps each measurement in its own place, with
+ * no weight on the ones it dropped.
  */
 export function pcaResult(
   pca: PcaLike,
@@ -108,8 +112,13 @@ export function pcaResult(
   }
   const width = first.length;
   const { mean, deviation } = columnStats(rows, width);
+  const record = pca.toJSON?.();
 
-  const weights = pca.getLoadings();
+  const weights = widenedLoadings(
+    pca.getLoadings(),
+    record?.excludedFeatures ?? NO_COLUMNS,
+    width,
+  );
   if (weights.columns < width) {
     throw new Error(
       `pcaResult was given rows ${width} measurements wide but a model holding ${weights.columns} weights, which is what \`ignoreZeroVariance\` leaves behind when it drops a column that never moves. Every panel after the dropped one would carry its neighbour's name.`,
@@ -147,50 +156,13 @@ export function pcaResult(
       variables: variables ?? numberedVariables(width),
       mean,
       spread,
-      scales: scaled ? deviation : undefined,
+      scales: (record?.scale ?? scaled) ? deviation : undefined,
       valueLabel,
     },
   };
 }
 
-function columnStats(
-  rows: readonly number[][],
-  width: number,
-): { mean: number[]; deviation: number[] } {
-  // Centred on the average so far, in one pass: a running total of the raw
-  // values squared loses the low bits of a spectrum sitting on a baseline.
-  // `deviation` carries the squared spread until the last loop roots it.
-  const mean = new Array<number>(width).fill(0);
-  const deviation = new Array<number>(width).fill(0);
-  for (let index = 0; index < rows.length; index++) {
-    const row = rows[index];
-    if (row?.length !== width) {
-      throw new Error(
-        `pcaResult was given a row ${row?.length ?? 0} measurements wide at index ${index}, where the first row is ${width} wide.`,
-      );
-    }
-    const seen = index + 1;
-    for (let column = 0; column < width; column++) {
-      const value = row[column];
-      if (value === undefined || !Number.isFinite(value)) {
-        throw new Error(
-          `pcaResult was given ${String(value)} at row ${index}, measurement ${column}. A model carries it on into a map of nothing at all.`,
-        );
-      }
-      const before = mean[column] ?? 0;
-      const step = value - before;
-      const after = before + step / seen;
-      mean[column] = after;
-      deviation[column] = (deviation[column] ?? 0) + step * (value - after);
-    }
-  }
-
-  const divisor = Math.max(1, rows.length - 1);
-  for (let column = 0; column < width; column++) {
-    deviation[column] = Math.sqrt((deviation[column] ?? 0) / divisor);
-  }
-  return { mean, deviation };
-}
+const NO_COLUMNS: readonly number[] = [];
 
 function signsOf(weights: MatrixLike, flip: boolean): Float64Array {
   const signs = new Float64Array(weights.rows).fill(1);