matterviz 0.3.1 → 0.3.3

package/dist/convex-hull/thermodynamics.js

@@ -1,7 +1,7 @@
 import { count_atoms_in_composition, extract_formula_elements, sort_by_electronegativity, } from '../composition';
 import * as math from '../math';
 import { barycentric_to_ternary_xyz, barycentric_to_tetrahedral, composition_to_barycentric_3d, composition_to_barycentric_4d, composition_to_barycentric_nd, } from './barycentric-coords';
-import { is_unary_entry } from './types';
+import { get_arity, HULL_STABILITY_TOL, is_on_hull, is_unary_entry } from './helpers';
 // Track warned keys to avoid log spam on large datasets with repeated invalid keys
 const warned_keys = new Set();
 // Normalize convex hull composition keys by stripping oxidation states (e.g. "V4+" -> "V")
@@ -41,7 +41,7 @@ export function process_hull_entries(entries) {
     for (const entry of normalized_entries) {
         const stable = typeof entry.is_stable === `boolean`
             ? entry.is_stable
-            : (entry.e_above_hull ?? Infinity) <= 1e-6;
+            : (entry.e_above_hull ?? Infinity) <= HULL_STABILITY_TOL;
         (stable ? stable_entries : unstable_entries).push(entry);
     }
     // Extract unique element symbols from normalized compositions
@@ -120,9 +120,9 @@ export function calculate_e_above_hull(input, reference_entries) {
     }
     // 3. Compute formation energies
     const refs = find_lowest_energy_unary_refs(reference_entries);
-    const compute_e_form = (e) => typeof e.e_form_per_atom === `number`
-        ? e.e_form_per_atom
-        : compute_e_form_per_atom(e, refs);
+    const compute_e_form = (entry) => typeof entry.e_form_per_atom === `number`
+        ? entry.e_form_per_atom
+        : compute_e_form_per_atom(entry, refs);
     const interest_data = entries_of_interest.map((entry) => ({
         entry,
         e_form: compute_e_form(entry),
@@ -192,8 +192,8 @@ export function calculate_e_above_hull(input, reference_entries) {
                 continue;
             try {
                 const bary = composition_to_barycentric_3d(ref.composition, elements);
-                const p = barycentric_to_ternary_xyz(bary, e_form);
-                ref_points.push(p);
+                const point = barycentric_to_ternary_xyz(bary, e_form);
+                ref_points.push(point);
             }
             catch {
                 // Ignore invalid compositions
@@ -202,7 +202,7 @@ export function calculate_e_above_hull(input, reference_entries) {
         // Ensure corner points (pure elements default to e_form = 0)
         for (const el of elements) {
             const corner = barycentric_to_ternary_xyz(composition_to_barycentric_3d({ [el]: 1 }, elements), 0);
-            if (!ref_points.some((p) => Math.hypot(p.x - corner.x, p.y - corner.y, p.z - corner.z) < 1e-9)) {
+            if (!ref_points.some((point) => Math.hypot(point.x - corner.x, point.y - corner.y, point.z - corner.z) < 1e-9)) {
                 ref_points.push(corner);
             }
         }
@@ -216,9 +216,9 @@ export function calculate_e_above_hull(input, reference_entries) {
             }
             try {
                 const bary = composition_to_barycentric_3d(entry.composition, elements);
-                const p = barycentric_to_ternary_xyz(bary, e_form);
-                const z_hull = e_hull_at_xy(hull_models, p.x, p.y);
-                results[id] = z_hull === null ? NaN : Math.max(0, p.z - z_hull);
+                const point = barycentric_to_ternary_xyz(bary, e_form);
+                const z_hull = e_hull_at_xy(hull_models, point.x, point.y);
+                results[id] = z_hull === null ? NaN : Math.max(0, point.z - z_hull);
             }
             catch {
                 results[id] = NaN;
@@ -245,8 +245,8 @@ export function calculate_e_above_hull(input, reference_entries) {
         for (const el of elements) {
             const tet = barycentric_to_tetrahedral(composition_to_barycentric_4d({ [el]: 1 }, elements));
             const corner = { ...tet, w: 0 };
-            const dist = (p) => Math.hypot(p.x - corner.x, p.y - corner.y, p.z - corner.z, p.w);
-            if (!ref_points.some((p) => dist(p) < 1e-9))
+            const dist = (point) => Math.hypot(point.x - corner.x, point.y - corner.y, point.z - corner.z, point.w);
+            if (!ref_points.some((point) => dist(point) < 1e-9))
                 ref_points.push(corner);
         }
         const hull_tetrahedra = compute_lower_hull_4d(ref_points);
@@ -359,38 +359,62 @@ export function calculate_e_above_hull(input, reference_entries) {
         }
     }
     if (is_single) {
-        const id = entries_of_interest[0].entry_id ??
-            JSON.stringify(entries_of_interest[0].composition);
+        const id = entries_of_interest[0].entry_id ?? JSON.stringify(entries_of_interest[0].composition);
         return results[id];
     }
     return results;
 }
-export function get_convex_hull_stats(processed_entries, elements, max_arity) {
-    if (!processed_entries || processed_entries.length === 0)
+export function get_convex_hull_stats(processed_entries, elements, max_arity = 4) {
+    if (processed_entries.length === 0)
         return null;
-    const composition_counts = (max_arity === 4 ? [1, 2, 3, 4] : [1, 2, 3]).map((target) => processed_entries.filter((entry) => Object.keys(entry.composition).filter((el) => (entry.composition[el] ?? 0) > 0).length === target).length);
-    const [unary, binary, ternary, quaternaryMaybe] = composition_counts;
-    const quaternary = max_arity === 4 ? (quaternaryMaybe ?? 0) : 0;
-    const stable_count = processed_entries.filter((e) => e.is_stable === true ||
-        (typeof e.e_above_hull === `number` && e.e_above_hull < 1e-6)).length;
+    max_arity = Math.max(1, max_arity);
+    let unary = 0;
+    let binary = 0;
+    let ternary = 0;
+    let quaternary = 0;
+    let quinary_plus = 0;
+    for (const entry of processed_entries) {
+        const arity = get_arity(entry);
+        if (arity === 1)
+            unary++;
+        else if (arity === 2)
+            binary++;
+        else if (arity === 3)
+            ternary++;
+        else if (arity === 4)
+            quaternary++;
+        else if (arity >= 5)
+            quinary_plus++;
+    }
+    // Zero out counts beyond system dimensionality for cleaner display
+    // quinary_plus is intentionally not zeroed — it's a catch-all bucket that
+    // is naturally 0 for systems with fewer than 5 elements
+    if (max_arity < 4)
+        quaternary = 0;
+    if (max_arity < 3)
+        ternary = 0;
+    if (max_arity < 2)
+        binary = 0;
+    const stable_count = processed_entries.filter((entry) => is_on_hull(entry)).length;
     const unstable_count = processed_entries.length - stable_count;
     const energies = processed_entries
-        .map((e) => e.e_form_per_atom ?? e.energy_per_atom)
-        .filter((v) => typeof v === `number` && Number.isFinite(v));
+        .map((entry) => entry.e_form_per_atom ?? entry.energy_per_atom ?? get_energy_per_atom(entry))
+        .filter(Number.isFinite);
+    // Use reduce instead of Math.min/max(...arr) to avoid stack overflow on large datasets
     const energy_range = energies.length > 0
         ? {
-            min: Math.min(...energies),
-            max: Math.max(...energies),
-            avg: energies.reduce((a, b) => a + b, 0) / energies.length,
+            min: energies.reduce((min, val) => (val < min ? val : min), Infinity),
+            max: energies.reduce((max, val) => (val > max ? val : max), -Infinity),
+            avg: energies.reduce((sum, val) => sum + val, 0) / energies.length,
         }
         : { min: 0, max: 0, avg: 0 };
     const hull_distances = processed_entries
-        .map((e) => e.e_above_hull)
-        .filter((v) => typeof v === `number` && v >= 0);
+        .map((entry) => entry.e_above_hull)
+        .filter((val) => typeof val === `number` && val >= 0);
     const hull_distance = hull_distances.length > 0
         ? {
-            max: Math.max(...hull_distances),
-            avg: hull_distances.reduce((a, b) => a + b, 0) / hull_distances.length,
+            max: hull_distances.reduce((max, val) => (val > max ? val : max), -Infinity),
+            avg: hull_distances.reduce((sum, val) => sum + val, 0) / hull_distances.length,
         }
         : { max: 0, avg: 0 };
     return {
@@ -399,26 +423,90 @@ export function get_convex_hull_stats(processed_entries, elements, max_arity) {
         binary,
         ternary,
         quaternary,
+        quinary_plus,
         stable: stable_count,
         unstable: unstable_count,
         energy_range,
         hull_distance,
         elements: elements.length,
         chemical_system: sort_by_electronegativity([...elements]).join(`-`),
+        max_arity,
+    };
+}
+// Convert a PhaseData entry to a ConvexHullEntry with default visual fields.
+// x/y/z default to 0 since high-dim systems aren't visually plotted.
+function to_hull_entry(entry) {
+    return {
+        ...entry,
+        visible: true,
+        is_element: get_arity(entry) === 1,
+        x: 0,
+        y: 0,
+        z: 0,
+    };
+}
+// Process raw hull entries for high-dimensional systems (5+ elements) where the
+// ConvexHull visual component can't render. Computes formation energies, hull distances,
+// stable/unstable classification, and phase stats. Returns null on failure.
+// Optionally accepts `elements` to scope the chemical system; if omitted, elements
+// are derived from the entries' compositions.
+export function process_hull_for_stats(entries, elements) {
+    if (!entries.length)
+        return null;
+    const processed = process_hull_entries(entries);
+    if (!processed.entries.length)
+        return null;
+    const hull_elements = elements ?? processed.elements;
+    // Compute formation energies
+    const el_refs = find_lowest_energy_unary_refs(processed.entries);
+    for (const entry of processed.entries) {
+        if (entry.e_form_per_atom === undefined) {
+            const e_form = compute_e_form_per_atom(entry, el_refs);
+            if (e_form !== null)
+                entry.e_form_per_atom = e_form;
+        }
+    }
+    // Compute hull distances. Note: entries without entry_id are keyed by
+    // JSON.stringify(composition), so polymorphs at the same composition
+    // collide — the last-processed entry's distance wins for all of them.
+    try {
+        const hull_distances = calculate_e_above_hull(processed.entries, processed.entries);
+        for (const entry of processed.entries) {
+            const dist = hull_distances[entry.entry_id ?? JSON.stringify(entry.composition)];
+            if (typeof dist === `number` && Number.isFinite(dist)) {
+                entry.e_above_hull = dist;
+                entry.is_stable = dist < HULL_STABILITY_TOL;
+            }
+            else {
+                // Clear stale hull metadata so previous values don't persist
+                entry.e_above_hull = undefined;
+                entry.is_stable = undefined;
+            }
+        }
+    }
+    catch (err) {
+        console.warn(`Failed to compute high-dim hull:`, err);
+        return null;
+    }
+    const hull_entries = processed.entries.map(to_hull_entry);
+    return {
+        stable_entries: hull_entries.filter((entry) => is_on_hull(entry)),
+        unstable_entries: hull_entries.filter((entry) => !is_on_hull(entry)),
+        phase_stats: get_convex_hull_stats(processed.entries, hull_elements, hull_elements.length),
     };
 }
 // --- 2D Convex Hull (Binary Phase Diagrams) ---
 export function compute_lower_hull_2d(points) {
     // Andrew's monotone chain for lower hull
     // Sort by x then y
-    const sorted = [...points].sort((p1, p2) => (p1.x - p2.x) || (p1.y - p2.y));
+    const sorted = [...points].sort((p1, p2) => p1.x - p2.x || p1.y - p2.y);
     const lower = [];
     const cross = (o, a, b) => (a.x - o.x) * (b.y - o.y) - (a.y - o.y) * (b.x - o.x);
-    for (const p of sorted) {
+    for (const point of sorted) {
         while (lower.length >= 2 &&
-            cross(lower[lower.length - 2], lower[lower.length - 1], p) <= 0)
+            cross(lower[lower.length - 2], lower[lower.length - 1], point) <= 0)
             lower.pop();
-        lower.push(p);
+        lower.push(point);
     }
     return lower;
 }
@@ -466,8 +554,7 @@ function compute_plane(p1, p2, p3) {
     const offset = -(normal.x * p1.x + normal.y * p1.y + normal.z * p1.z);
     return { normal, offset };
 }
-const point_plane_signed_distance = (plane, point) => plane.normal.x * point.x + plane.normal.y * point.y + plane.normal.z * point.z +
-    plane.offset;
+const point_plane_signed_distance = (plane, point) => plane.normal.x * point.x + plane.normal.y * point.y + plane.normal.z * point.z + plane.offset;
 const compute_centroid = (p1, p2, p3) => ({
     x: (p1.x + p2.x + p3.x) / 3,
     y: (p1.y + p2.y + p3.y) / 3,
@@ -569,7 +656,11 @@ function build_horizon(faces, visible_face_indices) {
     for (const face_idx of visible_face_indices) {
         const face = faces[face_idx];
         const [a, b, c] = face.vertices;
-        const edges = [[a, b], [b, c], [c, a]];
+        const edges = [
+            [a, b],
+            [b, c],
+            [c, a],
+        ];
         for (const [u, v] of edges) {
             const key = u < v ? `${u}|${v}` : `${v}|${u}`;
             if (!edge_count.has(key))
@@ -692,8 +783,7 @@ export const build_lower_hull_model = (faces) => faces.map((tri) => {
             return { a: 0, b: 0, c: (z1 + z2 + z3) / 3 };
         const a = (z1 * (y2 - y3) + z2 * (y3 - y1) + z3 * (y1 - y2)) / det;
         const b = (z1 * (x3 - x2) + z2 * (x1 - x3) + z3 * (x2 - x1)) / det;
-        const c = (z1 * (x2 * y3 - x3 * y2) + z2 * (x3 * y1 - x1 * y3) + z3 * (x1 * y2 - x2 * y1)) /
-            det;
+        const c = (z1 * (x2 * y3 - x3 * y2) + z2 * (x3 * y1 - x1 * y3) + z3 * (x1 * y2 - x2 * y1)) / det;
         return { a, b, c };
     })();
     const [min_x, _mx, max_x] = [p1.x, p2.x, p3.x].sort((a, b) => a - b);
@@ -731,22 +821,24 @@ function point_in_triangle_xy(model, x, y) {
 }
 export function e_hull_at_xy(models, x, y) {
     let z = null;
-    for (const m of models) {
-        if (x < m.min_x - 1e-9 || x > m.max_x + 1e-9 || y < m.min_y - 1e-9 || y > m.max_y + 1e-9)
+    for (const model of models) {
+        if (x < model.min_x - 1e-9 ||
+            x > model.max_x + 1e-9 ||
+            y < model.min_y - 1e-9 ||
+            y > model.max_y + 1e-9)
             continue;
-        if (!point_in_triangle_xy(m, x, y))
+        if (!point_in_triangle_xy(model, x, y))
             continue;
-        const z_face = m.a * x + m.b * y + m.c;
+        const z_face = model.a * x + model.b * y + model.c;
         z = z === null ? z_face : Math.min(z, z_face);
     }
     return z;
 }
-export const compute_e_above_hull_for_points = (points, models) => points.map((p) => {
-    const z_hull = e_hull_at_xy(models, p.x, p.y);
+export const compute_e_above_hull_for_points = (points, models) => points.map((point) => {
+    const z_hull = e_hull_at_xy(models, point.x, point.y);
     if (z_hull === null)
         return 0;
-    const e_above_hull = p.z - z_hull;
-    return e_above_hull > EPS ? e_above_hull : 0;
+    return point.z - z_hull;
 });
 const subtract_4d = (pt1, pt2) => ({
     x: pt1.x - pt2.x,
@@ -816,8 +908,7 @@ function compute_plane_4d(p1, p2, p3, p4) {
     const [x, y, z, w] = normal_components;
     const normal = normalize_4d({ x, y, z, w });
     // Guard against degenerate (nearly co-planar) points
-    const normal_magnitude = Math.abs(normal.x) + Math.abs(normal.y) + Math.abs(normal.z) +
-        Math.abs(normal.w);
+    const normal_magnitude = Math.abs(normal.x) + Math.abs(normal.y) + Math.abs(normal.z) + Math.abs(normal.w);
     if (normal_magnitude < EPS) {
         return { normal: { x: 0, y: 0, z: 0, w: 0 }, offset: 0 };
     }
@@ -900,8 +991,7 @@ function choose_initial_4_simplex(points) {
                 continue;
             const pa = points[idx_a];
             const pb = points[idx_b];
-            const dist_sq = (pa.x - pb.x) ** 2 + (pa.y - pb.y) ** 2 + (pa.z - pb.z) ** 2 +
-                (pa.w - pb.w) ** 2;
+            const dist_sq = (pa.x - pb.x) ** 2 + (pa.y - pb.y) ** 2 + (pa.z - pb.z) ** 2 + (pa.w - pb.w) ** 2;
             if (dist_sq > max_dist_sq) {
                 max_dist_sq = dist_sq;
                 idx_far_a = idx_a;
@@ -944,7 +1034,9 @@ function choose_initial_4_simplex(points) {
     let idx_far_hyperplane = -1;
     let best_dist_hyperplane = -1;
     for (let idx = 0; idx < points.length; idx++) {
-        if (idx === idx_far_a || idx === idx_far_b || idx === idx_far_line ||
+        if (idx === idx_far_a ||
+            idx === idx_far_b ||
+            idx === idx_far_line ||
             idx === idx_far_plane)
             continue;
         const dist = Math.abs(point_plane_signed_distance_4d(plane0, points[idx]));
@@ -1007,7 +1099,12 @@ function build_horizon_4d(faces, visible_face_indices) {
         const face = faces[face_idx];
         const [a, b, c, d] = face.vertices;
         // Each tetrahedron face has 4 triangular ridges
-        const ridges = [[a, b, c], [a, b, d], [a, c, d], [b, c, d]];
+        const ridges = [
+            [a, b, c],
+            [a, b, d],
+            [a, c, d],
+            [b, c, d],
+        ];
         for (const ridge of ridges) {
             const sorted = ridge.slice().sort((x, y) => x - y);
             const key = sorted.join(`|`);
@@ -1163,8 +1260,8 @@ function point_in_tetrahedron_3d(p0, p1, p2, p3, point) {
     }
     // Check if inside: all barycentric coords must be >= 0 and sum to 1
     const eps_bary = -1e-9;
-    const inside = bary.every((l) => l >= eps_bary) &&
-        Math.abs(bary.reduce((s, l) => s + l, 0) - 1) < 1e-6;
+    const inside = bary.every((coord) => coord >= eps_bary) &&
+        Math.abs(bary.reduce((sum, coord) => sum + coord, 0) - 1) < 1e-6;
     return { inside, bary };
 }
 const build_tetrahedron_models = (hull_tetrahedra) => hull_tetrahedra.map((tet) => {
@@ -1197,17 +1294,19 @@ export const compute_e_above_hull_4d = (points, hull_tetrahedra) => {
         let hull_w = null;
         for (const model of models) {
             // Fast bounding box prefilter
-            if (x < model.min_x - EPS || x > model.max_x + EPS ||
-                y < model.min_y - EPS || y > model.max_y + EPS ||
-                z < model.min_z - EPS || z > model.max_z + EPS)
+            if (x < model.min_x - EPS ||
+                x > model.max_x + EPS ||
+                y < model.min_y - EPS ||
+                y > model.max_y + EPS ||
+                z < model.min_z - EPS ||
+                z > model.max_z + EPS)
                 continue;
             // Check if point's (x,y,z) is inside the 3D projection of the tetrahedron
             const { inside, bary } = point_in_tetrahedron_3d(model.vertices_3d[0], model.vertices_3d[1], model.vertices_3d[2], model.vertices_3d[3], { x, y, z });
             if (inside) {
                 // Compute w on the hull at this (x,y,z) using barycentric interpolation
                 const [p0, p1, p2, p3] = model.vertices;
-                const w_on_hull = bary[0] * p0.w + bary[1] * p1.w + bary[2] * p2.w +
-                    bary[3] * p3.w;
+                const w_on_hull = bary[0] * p0.w + bary[1] * p1.w + bary[2] * p2.w + bary[3] * p3.w;
                 hull_w = hull_w === null ? w_on_hull : Math.min(hull_w, w_on_hull);
             }
         }
@@ -1215,8 +1314,7 @@ export const compute_e_above_hull_4d = (points, hull_tetrahedra) => {
         // composition domain. Return NaN to indicate invalid input.
         if (hull_w === null)
             return NaN;
-        const distance = w - hull_w;
-        return distance > EPS ? distance : 0;
+        return w - hull_w;
     });
 };
 // --- N-Dimensional Convex Hull (for 5+ element systems) ---
@@ -1254,10 +1352,7 @@ function compute_hyperplane_nd(points) {
     const normal_components = [];
     for (let col = 0; col < dim; col++) {
         // Build (N-1)×(N-1) submatrix by removing column col
-        const submatrix = edges.map((row) => [
-            ...row.slice(0, col),
-            ...row.slice(col + 1),
-        ]);
+        const submatrix = edges.map((row) => [...row.slice(0, col), ...row.slice(col + 1)]);
         const sign = col % 2 === 0 ? 1 : -1;
         normal_components.push(sign * math.det_nxn(submatrix));
     }
@@ -1652,7 +1747,6 @@ export function compute_e_above_hull_nd(query_points, hull_facets, all_points) {
         // would falsely imply the point is stable/on-hull).
         if (hull_energy === null)
             return NaN;
-        const distance = energy - hull_energy;
-        return distance > EPS ? distance : 0;
+        return energy - hull_energy;
     });
 }

package/dist/convex-hull/types.d.ts

@@ -3,12 +3,14 @@ import type { ShowControlsProp } from '../controls';
 import type { ElementSymbol } from '../element';
 import type { Vec3 } from '../math';
 import type { Sides } from '../plot';
+import type { Rect } from '../plot/layout';
 export interface PhaseData {
     composition: CompositionType;
     energy: number;
     entry_id?: string;
     e_above_hull?: number;
     is_stable?: boolean;
+    exclude_from_hull?: boolean;
     energy_per_atom?: number;
     e_form_per_atom?: number;
     reduced_formula?: string;
@@ -38,7 +40,8 @@ export interface Point2D {
 export interface Point3D extends Point2D {
     z: number;
 }
-export type MarkerSymbol = `circle` | `star` | `triangle` | `cross` | `diamond` | `square` | `wye`;
+export type MarkerSymbol = // Marker symbol types for convex hull entries
+`circle` | `star` | `triangle` | `cross` | `diamond` | `square` | `wye`;
 export type HullFaceColorMode = `uniform` | `formation_energy` | `dominant_element` | `facet_index`;
 export declare const HULL_FACE_COLOR_MODES: readonly HullFaceColorMode[];
 export interface ConvexHullEntry extends PhaseData, Point3D {
@@ -93,6 +96,11 @@ export interface ConvexHullTriangle {
     normal: Point3D;
     centroid: Point3D;
 }
+export interface LabelPlacement {
+    x: number;
+    y: number;
+    rect: Rect;
+}
 export interface HoverData3D<T = ConvexHullEntry> {
     entry: T;
     position: {
@@ -106,6 +114,7 @@ export interface PhaseStats {
     binary: number;
     ternary: number;
     quaternary: number;
+    quinary_plus: number;
     stable: number;
     unstable: number;
     energy_range: {
@@ -119,18 +128,9 @@ export interface PhaseStats {
     };
     elements: number;
     chemical_system: string;
+    max_arity: number;
 }
-export declare const get_arity: (entry: PhaseData) => number;
-export declare const is_unary_entry: (entry: PhaseData) => boolean;
-export declare const is_binary_entry: (entry: PhaseData) => boolean;
-export declare const is_ternary_entry: (entry: PhaseData) => boolean;
-export declare const is_quaternary_entry: (entry: PhaseData) => boolean;
-export declare const is_quinary_entry: (entry: PhaseData) => boolean;
-export declare const is_senary_entry: (entry: PhaseData) => boolean;
-export declare const is_septenary_entry: (entry: PhaseData) => boolean;
-export declare const is_octonary_entry: (entry: PhaseData) => boolean;
-export declare const is_nonary_entry: (entry: PhaseData) => boolean;
-export declare const is_denary_entry: (entry: PhaseData) => boolean;
+export type PhaseArityField = Extract<keyof PhaseStats, `unary` | `binary` | `ternary` | `quaternary` | `quinary_plus`>;
 export interface HighlightStyle {
     effect?: `pulse` | `glow` | `size` | `color` | `both`;
     color?: string;

package/dist/convex-hull/types.js

@@ -4,18 +4,6 @@ export const HULL_FACE_COLOR_MODES = [
     `dominant_element`,
     `facet_index`,
 ];
-// Arity helpers (inlined from former arity.ts)
-export const get_arity = (entry) => Object.values(entry.composition).filter((count) => count > 0).length;
-export const is_unary_entry = (entry) => get_arity(entry) === 1;
-export const is_binary_entry = (entry) => get_arity(entry) === 2;
-export const is_ternary_entry = (entry) => get_arity(entry) === 3;
-export const is_quaternary_entry = (entry) => get_arity(entry) === 4;
-export const is_quinary_entry = (entry) => get_arity(entry) === 5;
-export const is_senary_entry = (entry) => get_arity(entry) === 6;
-export const is_septenary_entry = (entry) => get_arity(entry) === 7;
-export const is_octonary_entry = (entry) => get_arity(entry) === 8;
-export const is_nonary_entry = (entry) => get_arity(entry) === 9;
-export const is_denary_entry = (entry) => get_arity(entry) === 10;
 // --- Gas Phase Thermodynamics ---
 // Default temperature (Kelvin) for gas corrections when no temperature is specified
 export const DEFAULT_GAS_TEMP = 300;