@mat3ra/made 2026.7.4-0 → 2026.7.13-0

package/pyproject.toml

@@ -16,7 +16,7 @@ classifiers = [
 ]
 dependencies = [
     "mat3ra-code",
-    "mat3ra-esse>=2026.6.30.post0",
+    "mat3ra-esse",
     "mat3ra-utils>=2026.7.3.post0",
     # new verison of numpy==2.0.0 is not handled by pymatgen yet
     "numpy<=1.26.4",

package/src/js/basis/basis.ts

@@ -1,12 +1,13 @@
 // @ts-ignore
 import { getElectronegativity, getElementAtomicRadius } from "@exabyte-io/periodic-table.js";
 import { InMemoryEntity } from "@mat3ra/code/dist/js/entity";
-import { math } from "@mat3ra/code/dist/js/math";
 import { BasisSchema, Coordinate3DSchema, Vector3DSchema } from "@mat3ra/esse/dist/js/types";
+import { Utils } from "@mat3ra/utils";
 import { chain, toPairs, uniq, values } from "lodash";
 
 import { Cell } from "../cell/cell";
 import { ATOMIC_COORD_UNITS, HASH_TOLERANCE } from "../constants";
+
 import {
     defaultNonPeriodicMinimumLatticeSize,
     diatomicLatticePaddingFactor,
@@ -247,7 +248,7 @@ export class Basis extends InMemoryEntity implements BasisSchema {
     toStandardRepresentation() {
         this.toCrystal();
         this._coordinates.mapArrayInPlace(
-            (point) => point.map((x) => math.mod(x)) as Coordinate3DSchema,
+            (point) => point.map((x) => Utils.math.mod(x)) as Coordinate3DSchema,
         );
     }
 
@@ -330,7 +331,7 @@ export class Basis extends InMemoryEntity implements BasisSchema {
     get formula(): string {
         const counts = this.uniqueElementCountsSortedByElectronegativity;
         const countsValues = values(counts);
-        const gcd = countsValues.length > 1 ? math.gcd(...countsValues) : countsValues[0];
+        const gcd = countsValues.length > 1 ? Utils.math.gcd(...countsValues) : countsValues[0];
 
         return toPairs(counts)
             .map(([element, count]) => element + (count / gcd === 1 ? "" : count / gcd))
@@ -392,7 +393,7 @@ export class Basis extends InMemoryEntity implements BasisSchema {
             const element = entry[0];
             const coordinate = entry[1];
             const atomicLabel = entry[2];
-            const toleratedCoordinate = coordinate.map((x) => math.round(x, HASH_TOLERANCE));
+            const toleratedCoordinate = coordinate.map((x) => Utils.math.roundCustom(x, HASH_TOLERANCE));
             return `${element}${atomicLabel} ${toleratedCoordinate.join()}`;
         });
         return `${standardRep.sort().join(";")};`;
@@ -471,7 +472,7 @@ export class Basis extends InMemoryEntity implements BasisSchema {
     hasEquivalentCellTo(anotherBasisClsInstance: Basis): boolean {
         return !this.cell.vectorArrays
             .map((vector, idx) => {
-                return math.vEqualWithTolerance(
+                return Utils.math.vEqualWithTolerance(
                     vector,
                     anotherBasisClsInstance.cell.vectorArrays[idx],
                 );
@@ -496,7 +497,7 @@ export class Basis extends InMemoryEntity implements BasisSchema {
         const maxDistance = this.maxPairwiseDistance;
         const minDistance = this.minPairwiseDistance;
         const widthRatio = maxDistance > 0 ? minDistance / maxDistance : 1;
-        const latticeScalingFactor = math.almostEqual(widthRatio, 1)
+        const latticeScalingFactor = Utils.math.almostEqual(widthRatio, 1)
             ? diatomicLatticePaddingFactor
             : molecularLatticePaddingFactor;
         const moleculeLatticeSize = maxDistance * latticeScalingFactor;
@@ -525,7 +526,7 @@ export class Basis extends InMemoryEntity implements BasisSchema {
                     (getElementAtomicRadius(el1) + getElementAtomicRadius(el2)); // in angstroms
 
                 // @ts-ignore
-                const distance = math.vDist(entry1.value, entry2.value) as number;
+                const distance = Utils.math.vDist(entry1.value, entry2.value) as number;
                 if (distance < tolerance) {
                     overlaps.push({
                         id1: i,
@@ -571,7 +572,7 @@ export class Basis extends InMemoryEntity implements BasisSchema {
         if (this._elements.values.length >= 2) {
             for (let i = 0; i < this._elements.values.length; i++) {
                 for (let j = i + 1; j < this._elements.values.length; j++) {
-                    const distance = math.vDist(
+                    const distance = Utils.math.vDist(
                         this._coordinates.getElementValueByIndex(i) as Coordinate3DSchema,
                         this._coordinates.getElementValueByIndex(j) as Coordinate3DSchema,
                     );

package/src/js/basis/coordinates.ts

@@ -1,13 +1,14 @@
 import { RoundedArrayWithIds, RoundedValueWithId, RoundedVector3D, Vector3D } from "@mat3ra/code";
-import { math } from "@mat3ra/code/dist/js/math";
 import {
     AtomicCoordinateSchema,
     Coordinate3DSchema,
     Matrix3X3Schema,
     Vector3DSchema,
 } from "@mat3ra/esse/dist/js/types";
+import { Utils } from "@mat3ra/utils";
 import { sprintf } from "underscore.string";
 
+
 export type AtomicCoordinateValue = AtomicCoordinateSchema["value"];
 
 type AxisType = "x" | "y" | "z";
@@ -78,7 +79,7 @@ export class Coordinates extends RoundedArrayWithIds<Coordinate3DSchema> {
     }
 
     getCenterPoint(): Vector3DSchema {
-        const transposed = math.transpose(this.values) as Matrix3X3Schema;
+        const transposed = Utils.math.transpose(this.values) as Matrix3X3Schema;
         const center: Vector3DSchema = [0, 0, 0];
 
         for (let i = 0; i < 3; i++) {

package/src/js/cell/cell.ts

@@ -1,17 +1,18 @@
 import { RoundedVector3D } from "@mat3ra/code";
-import { math } from "@mat3ra/code/dist/js/math";
 import {
     Coordinate3DSchema,
     LatticeVectorsSchema as CellSchema,
     Matrix3X3Schema,
     Vector3DSchema,
 } from "@mat3ra/esse/dist/js/types";
+import { Utils } from "@mat3ra/utils";
 
 import constants from "../constants";
 
-const MATRIX = math.matrix;
-const MULT = math.multiply;
-const INV = math.inv;
+
+const MATRIX = Utils.math.matrix;
+const MULT = Utils.math.multiply;
+const INV = Utils.math.inv;
 // @ts-ignore
 const MATRIX_MULT = (...args) => MULT(...args.map((x) => MATRIX(x))).toArray();
 
@@ -74,11 +75,11 @@ export class Cell implements CellSchema {
     }
 
     get volume(): number {
-        return math.det(this.vectorArrays);
+        return Utils.math.det(this.vectorArrays);
     }
 
     get volumeRounded(): number {
-        return math.roundArrayOrNumber(this.volume, Cell.roundPrecision) as number;
+        return Utils.math.roundArrayOrNumber(this.volume, Cell.roundPrecision) as number;
     }
 
     clone(): Cell {
@@ -103,7 +104,7 @@ export class Cell implements CellSchema {
         const { tolerance } = this.constructor as typeof Cell;
         return (
             this.convertPointToCrystal(point)
-                .map((c: number) => math.isBetweenZeroInclusiveAndOne(c, tolerance))
+                .map((c: number) => Utils.math.isBetweenZeroInclusiveAndOne(c, tolerance))
                 // @ts-ignore
                 .reduce((a: boolean, b: boolean): boolean => a && b)
         );
@@ -114,7 +115,7 @@ export class Cell implements CellSchema {
         const { tolerance } = this.constructor as typeof Cell;
         return (
             point
-                .map((c: number) => math.isBetweenZeroInclusiveAndOne(c, tolerance))
+                .map((c: number) => Utils.math.isBetweenZeroInclusiveAndOne(c, tolerance))
                 // @ts-ignore
                 .reduce((a: boolean, b: boolean): boolean => a && b)
         );
@@ -128,11 +129,12 @@ export class Cell implements CellSchema {
     }
 
     getMostCollinearVectorIndex(testVector: Vector3DSchema): number {
-        const angles = this.vectorArrays.map((v) => math.angleUpTo90(v, testVector, "deg"));
-        return angles.findIndex((el: number) => el === math.min(angles));
+        const angles = this.vectorArrays.map((v) => Utils.math.angleUpTo90(v, testVector, "deg"));
+        return angles.findIndex((el: number) => el === Utils.math.min(angles));
     }
 
     scaleByMatrix(matrix: number[][]) {
+        // @ts-ignore - mathjs v12 multiply return type is broader than runtime
         [this.a, this.b, this.c] = MATRIX_MULT(matrix, this.vectorArrays);
     }
 

package/src/js/cell/primitive_cell.ts

@@ -1,5 +1,5 @@
-import { math } from "@mat3ra/code/dist/js/math";
 import { LatticeSchema, Matrix3X3Schema } from "@mat3ra/esse/dist/js/types";
+import { Utils } from "@mat3ra/utils";
 
 /**
  * Routines for calculating primitive cell vectors from conventional cell Bravais parameters.
@@ -80,42 +80,45 @@ const PRIMITIVE_CELLS = {
 
     HEX: ({ a, c }: LatticeSchema): Matrix3X3Schema => {
         return [
-            [a / 2, (-a * math.sqrt(3)) / 2, 0],
-            [a / 2, (a * math.sqrt(3)) / 2, 0],
+            [a / 2, (-a * Number(Utils.math.sqrt(3))) / 2, 0],
+            [a / 2, (a * Number(Utils.math.sqrt(3))) / 2, 0],
             [0, 0, c],
         ];
     },
 
     RHL: ({ a, alpha }: LatticeSchema): Matrix3X3Schema => {
-        const cosAlpha = math.cos((alpha / 180) * math.PI);
-        const cosHalfAlpha = math.sqrt((1 / 2) * (1 + cosAlpha));
-        const sinHalfAlpha = math.sqrt((1 / 2) * (1 - cosAlpha));
+        const cosAlpha = Number(Utils.math.cos((alpha / 180) * Number(Utils.math.PI)));
+        const cosHalfAlpha = Number(Utils.math.sqrt((1 / 2) * (1 + cosAlpha)));
+        const sinHalfAlpha = Number(Utils.math.sqrt((1 / 2) * (1 - cosAlpha)));
         return [
             [a * cosHalfAlpha, -a * sinHalfAlpha, 0.0],
             [a * cosHalfAlpha, a * sinHalfAlpha, 0.0],
             [
                 (a * cosAlpha) / cosHalfAlpha,
                 0.0,
-                a * math.sqrt(1 - (cosAlpha * cosAlpha) / (cosHalfAlpha * cosHalfAlpha)),
+                a *
+                    Number(
+                        Utils.math.sqrt(1 - (cosAlpha * cosAlpha) / (cosHalfAlpha * cosHalfAlpha)),
+                    ),
             ],
         ];
     },
 
     MCL: ({ a, b, c, alpha }: LatticeSchema): Matrix3X3Schema => {
-        const cosAlpha = math.cos((alpha / 180) * math.PI);
+        const cosAlpha = Number(Utils.math.cos((alpha / 180) * Number(Utils.math.PI)));
         return [
             [a, 0, 0],
             [0, b, 0],
-            [0, c * cosAlpha, c * math.sqrt(1 - cosAlpha * cosAlpha)],
+            [0, c * cosAlpha, c * Number(Utils.math.sqrt(1 - cosAlpha * cosAlpha))],
         ];
     },
 
     MCLC: ({ a, b, c, alpha }: LatticeSchema): Matrix3X3Schema => {
-        const cosAlpha = math.cos((alpha / 180) * math.PI);
+        const cosAlpha = Number(Utils.math.cos((alpha / 180) * Number(Utils.math.PI)));
         return [
             [a / 2, b / 2, 0],
             [-a / 2, b / 2, 0],
-            [0, c * cosAlpha, c * math.sqrt(1 - cosAlpha * cosAlpha)],
+            [0, c * cosAlpha, c * Number(Utils.math.sqrt(1 - cosAlpha * cosAlpha))],
         ];
     },
 
@@ -123,22 +126,23 @@ const PRIMITIVE_CELLS = {
     TRI: ({ a, b, c, alpha, beta, gamma }: LatticeSchema): Matrix3X3Schema => {
         // convert angles to Radians
         // eslint-disable-next-line no-param-reassign
-        [alpha, beta, gamma] = [alpha, beta, gamma].map(
-            // @ts-ignore
-            (x) => math.unit(x, "degree").to("rad").value,
+        [alpha, beta, gamma] = [alpha, beta, gamma].map((x) =>
+            Number(Utils.math.unit(x, "degree").to("rad").value),
         );
 
-        const [cosAlpha, cosBeta, cosGamma] = [alpha, beta, gamma].map((x) => math.cos(x));
-        const [sinAlpha, sinBeta] = [alpha, beta].map((x) => math.sin(x));
+        const [cosAlpha, cosBeta, cosGamma] = [alpha, beta, gamma].map((x) =>
+            Number(Utils.math.cos(x)),
+        );
+        const [sinAlpha, sinBeta] = [alpha, beta].map((x) => Number(Utils.math.sin(x)));
         let acosArg = (cosAlpha * cosBeta - cosGamma) / (sinAlpha * sinBeta);
         if (acosArg < -1) {
             acosArg = -1;
         } else if (acosArg > 1) {
             acosArg = 1;
         }
-        const gammaStar = math.acos(acosArg);
-        const cosGammaStar = math.cos(gammaStar);
-        const sinGammaStar = math.sin(gammaStar);
+        const gammaStar = Number(Utils.math.acos(acosArg));
+        const cosGammaStar = Number(Utils.math.cos(gammaStar));
+        const sinGammaStar = Number(Utils.math.sin(gammaStar));
 
         return [
             [a * sinBeta, 0.0, a * cosBeta],

package/src/js/lattice/lattice.ts

@@ -1,6 +1,4 @@
-import { HASH_TOLERANCE } from "@mat3ra/code/dist/js/constants";
 import { InMemoryEntity } from "@mat3ra/code/dist/js/entity";
-import { math } from "@mat3ra/code/dist/js/math";
 import {
     Coordinate3DSchema,
     LatticeSchema,
@@ -9,6 +7,7 @@ import {
     LatticeVectorsSchema,
     Matrix3X3Schema,
 } from "@mat3ra/esse/dist/js/types";
+import { Utils } from "@mat3ra/utils";
 import * as lodash from "lodash";
 
 import { Cell } from "../cell/cell";
@@ -16,6 +15,7 @@ import { getPrimitiveLatticeVectorsFromConfig } from "../cell/primitive_cell";
 import { LATTICE_TYPE_CONFIGS } from "./lattice_types";
 import { UnitCell, UnitCellProps } from "./unit_cell";
 
+const { HASH_TOLERANCE } = Utils.constants;
 /**
  * Scaling factor used to calculate the new lattice size for non-periodic systems.
  * The scaling factor ensures that a non-periodic structure will have have a lattice greater than the structures size.
@@ -86,19 +86,21 @@ export class Lattice extends InMemoryEntity implements LatticeSchema {
         const { b } = this;
         const { c } = this;
 
-        const alphaRad = math.unit(this.alpha, "deg").toNumber("rad");
-        const betaRad = math.unit(this.beta, "deg").toNumber("rad");
-        const gammaRad = math.unit(this.gamma, "deg").toNumber("rad");
+        const alphaRad = Utils.math.unit(this.alpha, "deg").toNumber("rad");
+        const betaRad = Utils.math.unit(this.beta, "deg").toNumber("rad");
+        const gammaRad = Utils.math.unit(this.gamma, "deg").toNumber("rad");
 
-        const cosAlpha = math.cos(alphaRad);
-        const cosBeta = math.cos(betaRad);
-        const cosGamma = math.cos(gammaRad);
-        const sinAlpha = math.sin(alphaRad);
-        const sinBeta = math.sin(betaRad);
+        const cosAlpha = Utils.math.cos(alphaRad);
+        const cosBeta = Utils.math.cos(betaRad);
+        const cosGamma = Utils.math.cos(gammaRad);
+        const sinAlpha = Utils.math.sin(alphaRad);
+        const sinBeta = Utils.math.sin(betaRad);
 
-        const gammaStar = math.acos((cosAlpha * cosBeta - cosGamma) / (sinAlpha * sinBeta));
-        const cosGammaStar = math.cos(gammaStar);
-        const sinGammaStar = math.sin(gammaStar);
+        const gammaStar = Utils.math.acos((cosAlpha * cosBeta - cosGamma) / (sinAlpha * sinBeta));
+        // @ts-ignore - mathjs v12 acos return type includes Complex, but inputs are always real
+        const cosGammaStar = Utils.math.cos(gammaStar);
+        // @ts-ignore
+        const sinGammaStar = Utils.math.sin(gammaStar);
 
         const vectorA: Coordinate3DSchema = [a * sinBeta, 0.0, a * cosBeta];
         const vectorB: Coordinate3DSchema = [
@@ -121,12 +123,12 @@ export class Lattice extends InMemoryEntity implements LatticeSchema {
         type: LatticeTypeEnum = "TRI",
     ): Lattice {
         const [aVec, bVec, cVec] = vectors;
-        const a = math.vlen(aVec);
-        const b = math.vlen(bVec);
-        const c = math.vlen(cVec);
-        const alpha = math.angle(bVec, cVec, "deg");
-        const beta = math.angle(aVec, cVec, "deg");
-        const gamma = math.angle(aVec, bVec, "deg");
+        const a = Utils.math.vlen(aVec);
+        const b = Utils.math.vlen(bVec);
+        const c = Utils.math.vlen(cVec);
+        const alpha = Utils.math.angle(bVec, cVec, "deg");
+        const beta = Utils.math.angle(aVec, cVec, "deg");
+        const gamma = Utils.math.angle(aVec, bVec, "deg");
 
         return new Lattice({
             a,
@@ -183,7 +185,7 @@ export class Lattice extends InMemoryEntity implements LatticeSchema {
      */
     get typeExtended(): LatticeTypeExtendedEnum {
         const { a, b, c, alpha, beta, gamma, type } = this;
-        const cosAlpha = math.cos((alpha / 180) * math.PI);
+        const cosAlpha = Utils.math.cos((alpha / 180) * Utils.math.PI);
 
         switch (type) {
             case "BCT":
@@ -220,7 +222,7 @@ export class Lattice extends InMemoryEntity implements LatticeSchema {
      * Calculate the volume of the lattice cell.
      */
     get volume(): number {
-        return math.abs(math.det(this.vectorArrays));
+        return Utils.math.abs(Utils.math.det(this.vectorArrays));
     }
 
     /*
@@ -228,7 +230,7 @@ export class Lattice extends InMemoryEntity implements LatticeSchema {
      * @param latticeConfig {Object} LatticeBravais config (see constructor)
      */
     static getDefaultPrimitiveLatticeConfigByType(latticeConfig: LatticeSchema) {
-        const f_ = math.roundArrayOrNumber;
+        const f_ = Utils.math.roundArrayOrNumber;
         // construct new primitive cell using lattice parameters and skip rounding the vectors
         const vectors = getPrimitiveLatticeVectorsFromConfig(latticeConfig);
         // create new lattice from primitive cell
@@ -268,7 +270,7 @@ export class Lattice extends InMemoryEntity implements LatticeSchema {
             scaledLattice.beta,
             scaledLattice.gamma,
         ]
-            .map((x) => math.round(x, HASH_TOLERANCE))
+            .map((x) => Utils.math.roundCustom(x, HASH_TOLERANCE))
             .join(";")};`;
     }
 

package/src/js/lattice/reciprocal/lattice_reciprocal.ts

@@ -1,12 +1,13 @@
 import { ATOMIC_COORD_UNITS, units as UNITS } from "@mat3ra/code/dist/js/constants";
-import { math } from "@mat3ra/code/dist/js/math";
 import { Vector3DSchema } from "@mat3ra/esse/dist/js/types";
+import { Utils } from "@mat3ra/utils";
 import lodash from "lodash";
 
 import { Lattice } from "../lattice";
 import { paths } from "./paths";
 import { symmetryPoints } from "./symmetry_points";
 
+
 export type KPointCoordinates = number[];
 export type KPointPath = Array<{
     point: string;
@@ -39,16 +40,16 @@ export class ReciprocalLattice extends Lattice {
      */
     get reciprocalVectors(): Vector3DSchema[] {
         const vectors_: Vector3DSchema[] = this.vectors.vectorArrays as Vector3DSchema[];
-        const a: number = math.vlen(vectors_[0]);
+        const a: number = Utils.math.vlen(vectors_[0]);
         const divider: number =
-            (math.multiply(
+            (Utils.math.multiply(
                 vectors_[0],
-                math.cross(vectors_[1], vectors_[2]),
+                Utils.math.cross(vectors_[1], vectors_[2]),
             ) as unknown as number) / a;
         return [
-            math.multiply(math.cross(vectors_[1], vectors_[2]), 1 / divider) as Vector3DSchema,
-            math.multiply(math.cross(vectors_[2], vectors_[0]), 1 / divider) as Vector3DSchema,
-            math.multiply(math.cross(vectors_[0], vectors_[1]), 1 / divider) as Vector3DSchema,
+            Utils.math.multiply(Utils.math.cross(vectors_[1], vectors_[2]), 1 / divider) as Vector3DSchema,
+            Utils.math.multiply(Utils.math.cross(vectors_[2], vectors_[0]), 1 / divider) as Vector3DSchema,
+            Utils.math.multiply(Utils.math.cross(vectors_[0], vectors_[1]), 1 / divider) as Vector3DSchema,
         ];
     }
 
@@ -56,7 +57,7 @@ export class ReciprocalLattice extends Lattice {
      * Norms of reciprocal vectors.
      */
     get reciprocalVectorNorms(): Vector3DSchema {
-        return this.reciprocalVectors.map((vec) => math.norm(vec) as number) as Vector3DSchema;
+        return this.reciprocalVectors.map((vec) => Utils.math.norm(vec) as number) as Vector3DSchema;
     }
 
     /**
@@ -64,7 +65,7 @@ export class ReciprocalLattice extends Lattice {
      */
     get reciprocalVectorRatios(): Vector3DSchema {
         const norms: number[] = this.reciprocalVectorNorms;
-        const maxNorm: number = math.max(...norms) as number;
+        const maxNorm: number = Utils.math.max(...norms) as number;
         return norms.map((n: number) => n / maxNorm) as Vector3DSchema;
     }
 
@@ -74,7 +75,7 @@ export class ReciprocalLattice extends Lattice {
      * @return {KPointCoordinates}
      */
     getCartesianCoordinates(point: KPointCoordinates): KPointCoordinates {
-        return math.multiply(point, this.reciprocalVectors) as KPointCoordinates;
+        return Utils.math.multiply(point, this.reciprocalVectors) as KPointCoordinates;
     }
 
     /**
@@ -105,7 +106,7 @@ export class ReciprocalLattice extends Lattice {
 
         dataPoints.forEach((point: KPointCoordinates, index: number) => {
             const symmPoint: SymmetryPoint | undefined = symmPoints.find((x) => {
-                return math.vEqualWithTolerance(x.coordinates, point, 1e-4);
+                return Utils.math.vEqualWithTolerance(x.coordinates, point, 1e-4);
             });
             if (symmPoint) {
                 kpointPath.push({
@@ -128,10 +129,10 @@ export class ReciprocalLattice extends Lattice {
     calculateDimension(nPoints: number, index: number): number {
         const norms: number[] = this.reciprocalVectorNorms;
         const [j, k] = [0, 1, 2].filter((i) => i !== index); // get indices of other two dimensions
-        const N: number = math.cbrt(
+        const N: number = Utils.math.cbrt(
             (nPoints * norms[index] ** 2) / (norms[j] * norms[k]),
         ) as number;
-        return math.max(1, math.ceil(N)) as number;
+        return Utils.math.max(1, Utils.math.ceil(N)) as number;
     }
 
     /**
@@ -148,10 +149,10 @@ export class ReciprocalLattice extends Lattice {
         const { a } = this;
         return {
             [ATOMIC_COORD_UNITS.cartesian]: {
-                [UNITS.angstrom]: (2 * math.PI) / a,
+                [UNITS.angstrom]: (2 * Utils.math.PI) / a,
             },
             [UNITS.angstrom]: {
-                [ATOMIC_COORD_UNITS.cartesian]: a / (2 * math.PI),
+                [ATOMIC_COORD_UNITS.cartesian]: a / (2 * Utils.math.PI),
             },
         };
     }
@@ -166,7 +167,7 @@ export class ReciprocalLattice extends Lattice {
     getDimensionsFromSpacing(spacing: number, units: string = ATOMIC_COORD_UNITS.cartesian) {
         const factor: number = this.conversionTable[units][ATOMIC_COORD_UNITS.cartesian] || 1;
         return this.reciprocalVectorNorms.map((norm: number) => {
-            return math.max(1, math.ceil(lodash.round(norm / (spacing * factor), 4))) as number;
+            return Utils.math.max(1, Utils.math.ceil(lodash.round(norm / (spacing * factor), 4))) as number;
         }) as Vector3DSchema;
     }
 
@@ -184,8 +185,8 @@ export class ReciprocalLattice extends Lattice {
         const norms: number[] = this.reciprocalVectorNorms;
         return (
             factor *
-            (math.mean(
-                dimensions.map((dim: number, i: number) => norms[i] / math.max(1, dim)),
+            (Utils.math.mean(
+                dimensions.map((dim: number, i: number) => norms[i] / Utils.math.max(1, dim)),
             ) as number)
         );
     }

package/src/js/parsers/poscar.ts

@@ -1,4 +1,3 @@
-import { math } from "@mat3ra/code/dist/js/math";
 import {
     BasisSchema,
     Coordinate3DSchema,
@@ -16,7 +15,8 @@ import { ATOMIC_COORD_UNITS } from "../constants";
 import { AtomicConstraintValue } from "../constraints/constraints";
 import { Lattice } from "../lattice/lattice";
 
-const _print = (x: number, printFormat = "%14.9f") => s.sprintf(printFormat, math.precise(x));
+
+const _print = (x: number, printFormat = "%14.9f") => s.sprintf(printFormat, Utils.math.precise(x));
 const _latticeVectorsToString = (vectors: Vector3DSchema[]) =>
     vectors.map((v) => v.map((c) => _print(c)).join("\t")).join("\n");
 const atomicConstraintsCharFromBool = (bool: boolean): string => (bool ? "T" : "F");

package/src/js/parsers/xyz_combinatorial_basis.ts

@@ -1,5 +1,5 @@
-import { math } from "@mat3ra/code/dist/js/math";
 import { BasisSchema } from "@mat3ra/esse/dist/js/types";
+import { Utils } from "@mat3ra/utils";
 import { chain, last, map } from "lodash";
 import * as s from "underscore.string";
 
@@ -8,6 +8,7 @@ import { AtomicCoordinateValue } from "../basis/coordinates";
 import { AtomicElementValue } from "../basis/elements";
 import { Cell } from "../cell/cell";
 
+
 /**
  * @summary Combinatorial XYZ basis class and related. Create and get all information about basis and elements in it.
  * Constructor accepts string in extended XYZ format. Extended XYZ format is as follows:
@@ -224,7 +225,7 @@ export class CombinatorialBasis {
             dimensions.push(itemsSet);
         });
         // @ts-ignore // We're multiplying objects with math, not numbers. No type casting will help.
-        const basisSet = math.cartesianProduct.apply(null, dimensions) as ElementWithCoordinate[][];
+        const basisSet = Utils.math.cartesianProduct.apply(null, dimensions) as ElementWithCoordinate[][];
         return basisSet.map((basis: ElementWithCoordinate[]) =>
             basis.filter((entry) => entry.element !== VACANCY_CHARACTER),
         );

package/src/js/tools/basis.ts

@@ -1,12 +1,13 @@
-import { math } from "@mat3ra/code/dist/js/math";
 import { Coordinate3DSchema } from "@mat3ra/esse/dist/js/types";
+import { Utils } from "@mat3ra/utils";
 import { chunk, flatten } from "lodash";
 
 import { Basis } from "../basis/basis";
 import { AtomicCoordinateValue, Coordinate } from "../basis/coordinates";
 
-const ADD = math.add;
-const MULT = math.multiply;
+
+const ADD = Utils.math.add;
+const MULT = Utils.math.multiply;
 
 /**
  * Returns a repeated basis of a crystal.

package/src/js/tools/cell.ts

@@ -1,8 +1,9 @@
-import { math } from "@mat3ra/code/dist/js/math";
 import { Coordinate3DSchema, Matrix3X3Schema } from "@mat3ra/esse/dist/js/types";
+import { Utils } from "@mat3ra/utils";
 
 import { Cell } from "../cell/cell";
 
+
 /**
  * Returns the list of points on the original lattice contained in the supercell in fractional coordinates.
  * Source: https://pymatgen.org/_modules/pymatgen/util/coord.html
@@ -22,8 +23,8 @@ function latticePointsInSupercell(supercellMatrix: Matrix3X3Schema) {
     const d_points = diagonals.map((point) =>
         supercell.convertPointToCartesian(point as Coordinate3DSchema),
     );
-    const mins = [0, 1, 2].map((i) => math.min(...d_points.map((p) => p[i])));
-    const maxes = [0, 1, 2].map((i) => math.max(...d_points.map((p) => p[i])) + 1);
+    const mins = [0, 1, 2].map((i) => Utils.math.min(...d_points.map((p) => p[i])));
+    const maxes = [0, 1, 2].map((i) => Utils.math.max(...d_points.map((p) => p[i])) + 1);
     const points = [];
     for (let i = mins[0]; i <= maxes[0]; i++) {
         for (let j = mins[1]; j <= maxes[1]; j++) {

package/src/js/tools/material.ts

@@ -1,10 +1,11 @@
-import { math } from "@mat3ra/code/dist/js/math";
 import { LatticeSchema, Vector3DSchema } from "@mat3ra/esse/dist/js/types";
+import { Utils } from "@mat3ra/utils";
 
 import { ATOMIC_COORD_UNITS } from "../constants";
 import { Lattice } from "../lattice/lattice";
 import { Material } from "../material";
 
+
 /**
  * Scales one lattice vector for the given material
  * @param material {Material} The material acted upon.
@@ -44,11 +45,11 @@ function translateAtomsToCenter(material: Material) {
     material.toCartesian();
     const updatedBasis = material.Basis;
     const centerOfCoordinates = updatedBasis.centerOfCoordinatesPoint;
-    const centerOfLattice = math.multiply(
+    const centerOfLattice = Utils.math.multiply(
         0.5,
-        material.Lattice.vectorArrays.reduce((a, b) => math.add(a, b) as Vector3DSchema),
+        material.Lattice.vectorArrays.reduce((a, b) => Utils.math.add(a, b) as Vector3DSchema),
     );
-    const translationVector = math.subtract(centerOfLattice, centerOfCoordinates);
+    const translationVector = Utils.math.subtract(centerOfLattice, centerOfCoordinates);
     updatedBasis.translateByVector(translationVector as Vector3DSchema);
     material.setBasis(updatedBasis.toJSON());
     if (originalUnits !== ATOMIC_COORD_UNITS.cartesian) material.toCrystal();

package/src/js/tools/supercell.ts

@@ -1,5 +1,5 @@
-import { math } from "@mat3ra/code/dist/js/math";
 import { Coordinate3DSchema, Matrix3X3Schema } from "@mat3ra/esse/dist/js/types";
+import { Utils } from "@mat3ra/utils";
 
 import { Basis } from "../basis/basis";
 import { ConstrainedBasis } from "../basis/constrained_basis";
@@ -8,7 +8,8 @@ import { Lattice } from "../lattice/lattice";
 import type { Material } from "../material";
 import cellTools from "./cell";
 
-const ADD = math.add;
+
+const ADD = Utils.math.add;
 
 /**
  * @summary Generates new basis for a supercell. For each site from basis generates shifts that are within supercell.
@@ -56,7 +57,7 @@ function generateNewBasisWithinSupercell(
  * @param supercellMatrix {Number[][]}
  */
 function generateConfig(material: Material, supercellMatrix: Matrix3X3Schema) {
-    const det = math.det(supercellMatrix);
+    const det = Utils.math.det(supercellMatrix);
     if (det === 0) {
         throw new Error("Scaling matrix is degenerate.");
     }