@mat3ra/made 2026.5.21-2 → 2026.5.28-0

package/dist/js/basis/basis.js

@@ -1,17 +1,14 @@
 "use strict";
-var __importDefault = (this && this.__importDefault) || function (mod) {
-    return (mod && mod.__esModule) ? mod : { "default": mod };
-};
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.Basis = void 0;
 // @ts-ignore
 const periodic_table_js_1 = require("@exabyte-io/periodic-table.js");
 const entity_1 = require("@mat3ra/code/dist/js/entity");
+const math_1 = require("@mat3ra/code/dist/js/math");
 const lodash_1 = require("lodash");
 const cell_1 = require("../cell/cell");
 const constants_1 = require("../constants");
 const lattice_1 = require("../lattice/lattice");
-const math_1 = __importDefault(require("../math"));
 const coordinates_1 = require("./coordinates");
 const elements_1 = require("./elements");
 const labels_1 = require("./labels");
@@ -166,7 +163,7 @@ class Basis extends entity_1.InMemoryEntity {
     }
     toStandardRepresentation() {
         this.toCrystal();
-        this._coordinates.mapArrayInPlace((point) => point.map((x) => math_1.default.mod(x)));
+        this._coordinates.mapArrayInPlace((point) => point.map((x) => math_1.math.mod(x)));
     }
     /** A representation where all coordinates are within 0 and 1 in crystal units */
     get standardRepresentation() {
@@ -240,7 +237,7 @@ class Basis extends entity_1.InMemoryEntity {
     get formula() {
         const counts = this.uniqueElementCountsSortedByElectronegativity;
         const countsValues = (0, lodash_1.values)(counts);
-        const gcd = countsValues.length > 1 ? math_1.default.gcd(...countsValues) : countsValues[0];
+        const gcd = countsValues.length > 1 ? math_1.math.gcd(...countsValues) : countsValues[0];
         return (0, lodash_1.toPairs)(counts)
             .map(([element, count]) => element + (count / gcd === 1 ? "" : count / gcd))
             .reduce((acc, part) => acc + part, "");
@@ -293,7 +290,7 @@ class Basis extends entity_1.InMemoryEntity {
             const element = entry[0];
             const coordinate = entry[1];
             const atomicLabel = entry[2];
-            const toleratedCoordinate = coordinate.map((x) => math_1.default.round(x, constants_1.HASH_TOLERANCE));
+            const toleratedCoordinate = coordinate.map((x) => math_1.math.round(x, constants_1.HASH_TOLERANCE));
             return `${element}${atomicLabel} ${toleratedCoordinate.join()}`;
         });
         return `${standardRep.sort().join(";")};`;
@@ -364,7 +361,7 @@ class Basis extends entity_1.InMemoryEntity {
     hasEquivalentCellTo(anotherBasisClsInstance) {
         return !this.cell.vectorArrays
             .map((vector, idx) => {
-            return math_1.default.vEqualWithTolerance(vector, anotherBasisClsInstance.cell.vectorArrays[idx]);
+            return math_1.math.vEqualWithTolerance(vector, anotherBasisClsInstance.cell.vectorArrays[idx]);
         })
             .some((x) => !x);
     }
@@ -401,7 +398,7 @@ class Basis extends entity_1.InMemoryEntity {
                 const tolerance = overlapCoefficient *
                     ((0, periodic_table_js_1.getElementAtomicRadius)(el1) + (0, periodic_table_js_1.getElementAtomicRadius)(el2)); // in angstroms
                 // @ts-ignore
-                const distance = math_1.default.vDist(entry1.value, entry2.value);
+                const distance = math_1.math.vDist(entry1.value, entry2.value);
                 if (distance < tolerance) {
                     overlaps.push({
                         id1: i,
@@ -437,7 +434,7 @@ class Basis extends entity_1.InMemoryEntity {
         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_1.default.vDist(this._coordinates.getElementValueByIndex(i), this._coordinates.getElementValueByIndex(j));
+                    const distance = math_1.math.vDist(this._coordinates.getElementValueByIndex(i), this._coordinates.getElementValueByIndex(j));
                     if (distance && distance > maxDistance) {
                         maxDistance = distance;
                     }

package/dist/js/basis/coordinates.js

@@ -1,12 +1,9 @@
 "use strict";
-var __importDefault = (this && this.__importDefault) || function (mod) {
-    return (mod && mod.__esModule) ? mod : { "default": mod };
-};
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.Coordinates = exports.Coordinate = void 0;
 const code_1 = require("@mat3ra/code");
+const math_1 = require("@mat3ra/code/dist/js/math");
 const underscore_string_1 = require("underscore.string");
-const math_1 = __importDefault(require("../math"));
 class Coordinate extends code_1.RoundedValueWithId {
     constructor({ value, id }) {
         super(id, value);
@@ -61,7 +58,7 @@ class Coordinates extends code_1.RoundedArrayWithIds {
         });
     }
     getCenterPoint() {
-        const transposed = math_1.default.transpose(this.values);
+        const transposed = math_1.math.transpose(this.values);
         const center = [0, 0, 0];
         for (let i = 0; i < 3; i++) {
             const axisCoords = transposed[i];

package/dist/js/cell/primitive_cell.js

@@ -1,10 +1,7 @@
 "use strict";
-var __importDefault = (this && this.__importDefault) || function (mod) {
-    return (mod && mod.__esModule) ? mod : { "default": mod };
-};
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.getPrimitiveLatticeVectorsFromConfig = void 0;
-const math_1 = __importDefault(require("../math"));
+const math_1 = require("@mat3ra/code/dist/js/math");
 /**
  * Routines for calculating primitive cell vectors from conventional cell Bravais parameters.
  * Following Setyawan, W., & Curtarolo, S. (2010). doi:10.1016/j.commatsci.2010.05.010
@@ -75,39 +72,39 @@ const PRIMITIVE_CELLS = {
     },
     HEX: ({ a, c }) => {
         return [
-            [a / 2, (-a * math_1.default.sqrt(3)) / 2, 0],
-            [a / 2, (a * math_1.default.sqrt(3)) / 2, 0],
+            [a / 2, (-a * math_1.math.sqrt(3)) / 2, 0],
+            [a / 2, (a * math_1.math.sqrt(3)) / 2, 0],
             [0, 0, c],
         ];
     },
     RHL: ({ a, alpha }) => {
-        const cosAlpha = math_1.default.cos((alpha / 180) * math_1.default.PI);
-        const cosHalfAlpha = math_1.default.sqrt((1 / 2) * (1 + cosAlpha));
-        const sinHalfAlpha = math_1.default.sqrt((1 / 2) * (1 - cosAlpha));
+        const cosAlpha = math_1.math.cos((alpha / 180) * math_1.math.PI);
+        const cosHalfAlpha = math_1.math.sqrt((1 / 2) * (1 + cosAlpha));
+        const sinHalfAlpha = math_1.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_1.default.sqrt(1 - (cosAlpha * cosAlpha) / (cosHalfAlpha * cosHalfAlpha)),
+                a * math_1.math.sqrt(1 - (cosAlpha * cosAlpha) / (cosHalfAlpha * cosHalfAlpha)),
             ],
         ];
     },
     MCL: ({ a, b, c, alpha }) => {
-        const cosAlpha = math_1.default.cos((alpha / 180) * math_1.default.PI);
+        const cosAlpha = math_1.math.cos((alpha / 180) * math_1.math.PI);
         return [
             [a, 0, 0],
             [0, b, 0],
-            [0, c * cosAlpha, c * math_1.default.sqrt(1 - cosAlpha * cosAlpha)],
+            [0, c * cosAlpha, c * math_1.math.sqrt(1 - cosAlpha * cosAlpha)],
         ];
     },
     MCLC: ({ a, b, c, alpha }) => {
-        const cosAlpha = math_1.default.cos((alpha / 180) * math_1.default.PI);
+        const cosAlpha = math_1.math.cos((alpha / 180) * math_1.math.PI);
         return [
             [a / 2, b / 2, 0],
             [-a / 2, b / 2, 0],
-            [0, c * cosAlpha, c * math_1.default.sqrt(1 - cosAlpha * cosAlpha)],
+            [0, c * cosAlpha, c * math_1.math.sqrt(1 - cosAlpha * cosAlpha)],
         ];
     },
     // Algorithm from http://pymatgen.org/_modules/pymatgen/core/lattice.html (from_params)
@@ -116,9 +113,9 @@ const PRIMITIVE_CELLS = {
         // eslint-disable-next-line no-param-reassign
         [alpha, beta, gamma] = [alpha, beta, gamma].map(
         // @ts-ignore
-        (x) => math_1.default.unit(x, "degree").to("rad").value);
-        const [cosAlpha, cosBeta, cosGamma] = [alpha, beta, gamma].map((x) => math_1.default.cos(x));
-        const [sinAlpha, sinBeta] = [alpha, beta].map((x) => math_1.default.sin(x));
+        (x) => math_1.math.unit(x, "degree").to("rad").value);
+        const [cosAlpha, cosBeta, cosGamma] = [alpha, beta, gamma].map((x) => math_1.math.cos(x));
+        const [sinAlpha, sinBeta] = [alpha, beta].map((x) => math_1.math.sin(x));
         let acosArg = (cosAlpha * cosBeta - cosGamma) / (sinAlpha * sinBeta);
         if (acosArg < -1) {
             acosArg = -1;
@@ -126,9 +123,9 @@ const PRIMITIVE_CELLS = {
         else if (acosArg > 1) {
             acosArg = 1;
         }
-        const gammaStar = math_1.default.acos(acosArg);
-        const cosGammaStar = math_1.default.cos(gammaStar);
-        const sinGammaStar = math_1.default.sin(gammaStar);
+        const gammaStar = math_1.math.acos(acosArg);
+        const cosGammaStar = math_1.math.cos(gammaStar);
+        const sinGammaStar = math_1.math.sin(gammaStar);
         return [
             [a * sinBeta, 0.0, a * cosBeta],
             [-b * sinAlpha * cosGammaStar, b * sinAlpha * sinGammaStar, b * cosAlpha],

package/dist/js/lattice/lattice.js

@@ -22,17 +22,14 @@ var __importStar = (this && this.__importStar) || function (mod) {
     __setModuleDefault(result, mod);
     return result;
 };
-var __importDefault = (this && this.__importDefault) || function (mod) {
-    return (mod && mod.__esModule) ? mod : { "default": mod };
-};
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.Lattice = exports.LatticeVectors = exports.nonPeriodicLatticeScalingFactor = void 0;
 const constants_1 = require("@mat3ra/code/dist/js/constants");
 const entity_1 = require("@mat3ra/code/dist/js/entity");
+const math_1 = require("@mat3ra/code/dist/js/math");
 const lodash = __importStar(require("lodash"));
 const cell_1 = require("../cell/cell");
 const primitive_cell_1 = require("../cell/primitive_cell");
-const math_1 = __importDefault(require("../math"));
 const lattice_types_1 = require("./lattice_types");
 const unit_cell_1 = require("./unit_cell");
 /**
@@ -69,17 +66,17 @@ class Lattice extends entity_1.InMemoryEntity {
         const { a } = this;
         const { b } = this;
         const { c } = this;
-        const alphaRad = math_1.default.unit(this.alpha, "deg").toNumber("rad");
-        const betaRad = math_1.default.unit(this.beta, "deg").toNumber("rad");
-        const gammaRad = math_1.default.unit(this.gamma, "deg").toNumber("rad");
-        const cosAlpha = math_1.default.cos(alphaRad);
-        const cosBeta = math_1.default.cos(betaRad);
-        const cosGamma = math_1.default.cos(gammaRad);
-        const sinAlpha = math_1.default.sin(alphaRad);
-        const sinBeta = math_1.default.sin(betaRad);
-        const gammaStar = math_1.default.acos((cosAlpha * cosBeta - cosGamma) / (sinAlpha * sinBeta));
-        const cosGammaStar = math_1.default.cos(gammaStar);
-        const sinGammaStar = math_1.default.sin(gammaStar);
+        const alphaRad = math_1.math.unit(this.alpha, "deg").toNumber("rad");
+        const betaRad = math_1.math.unit(this.beta, "deg").toNumber("rad");
+        const gammaRad = math_1.math.unit(this.gamma, "deg").toNumber("rad");
+        const cosAlpha = math_1.math.cos(alphaRad);
+        const cosBeta = math_1.math.cos(betaRad);
+        const cosGamma = math_1.math.cos(gammaRad);
+        const sinAlpha = math_1.math.sin(alphaRad);
+        const sinBeta = math_1.math.sin(betaRad);
+        const gammaStar = math_1.math.acos((cosAlpha * cosBeta - cosGamma) / (sinAlpha * sinBeta));
+        const cosGammaStar = math_1.math.cos(gammaStar);
+        const sinGammaStar = math_1.math.sin(gammaStar);
         const vectorA = [a * sinBeta, 0.0, a * cosBeta];
         const vectorB = [
             -b * sinAlpha * cosGammaStar,
@@ -94,12 +91,12 @@ class Lattice extends entity_1.InMemoryEntity {
     }
     static fromVectorsArray(vectors, units = Lattice.defaultConfig.units, type = "TRI") {
         const [aVec, bVec, cVec] = vectors;
-        const a = math_1.default.vlen(aVec);
-        const b = math_1.default.vlen(bVec);
-        const c = math_1.default.vlen(cVec);
-        const alpha = math_1.default.angle(bVec, cVec, "deg");
-        const beta = math_1.default.angle(aVec, cVec, "deg");
-        const gamma = math_1.default.angle(aVec, bVec, "deg");
+        const a = math_1.math.vlen(aVec);
+        const b = math_1.math.vlen(bVec);
+        const c = math_1.math.vlen(cVec);
+        const alpha = math_1.math.angle(bVec, cVec, "deg");
+        const beta = math_1.math.angle(aVec, cVec, "deg");
+        const gamma = math_1.math.angle(aVec, bVec, "deg");
         return new Lattice({
             a,
             b,
@@ -144,7 +141,7 @@ class Lattice extends entity_1.InMemoryEntity {
      */
     get typeExtended() {
         const { a, b, c, alpha, beta, gamma, type } = this;
-        const cosAlpha = math_1.default.cos((alpha / 180) * math_1.default.PI);
+        const cosAlpha = math_1.math.cos((alpha / 180) * math_1.math.PI);
         switch (type) {
             case "BCT":
                 return c < a ? "BCT-1" : "BCT-2";
@@ -179,14 +176,14 @@ class Lattice extends entity_1.InMemoryEntity {
      * Calculate the volume of the lattice cell.
      */
     get volume() {
-        return math_1.default.abs(math_1.default.det(this.vectorArrays));
+        return math_1.math.abs(math_1.math.det(this.vectorArrays));
     }
     /*
      * Returns a "default" primitive lattice by type, with lattice parameters scaled by the length of "a",
      * @param latticeConfig {Object} LatticeBravais config (see constructor)
      */
     static getDefaultPrimitiveLatticeConfigByType(latticeConfig) {
-        const f_ = math_1.default.roundArrayOrNumber;
+        const f_ = math_1.math.roundArrayOrNumber;
         // construct new primitive cell using lattice parameters and skip rounding the vectors
         const vectors = (0, primitive_cell_1.getPrimitiveLatticeVectorsFromConfig)(latticeConfig);
         // create new lattice from primitive cell
@@ -224,7 +221,7 @@ class Lattice extends entity_1.InMemoryEntity {
             scaledLattice.beta,
             scaledLattice.gamma,
         ]
-            .map((x) => math_1.default.round(x, constants_1.HASH_TOLERANCE))
+            .map((x) => math_1.math.round(x, constants_1.HASH_TOLERANCE))
             .join(";")};`;
     }
     /**

package/dist/js/lattice/reciprocal/lattice_reciprocal.d.ts

@@ -23,14 +23,12 @@ export declare class ReciprocalLattice extends Lattice {
     get reciprocalVectors(): Vector3DSchema[];
     /**
      * Norms of reciprocal vectors.
-     * @return {number[]}
      */
-    get reciprocalVectorNorms(): number[];
+    get reciprocalVectorNorms(): Vector3DSchema;
     /**
      * Ratio of reciprocal vector norms scaled by the inverse of the largest component.
-     * @return {number[]}
      */
-    get reciprocalVectorRatios(): number[];
+    get reciprocalVectorRatios(): Vector3DSchema;
     /**
      * Get point (in crystal coordinates) in cartesian coordinates.
      * @param {KPointCoordinates} point - point in 3D space
@@ -67,9 +65,9 @@ export declare class ReciprocalLattice extends Lattice {
     /**
      * Calculate grid dimensions from total number of k-points.
      * @param {number} nKpoints - Total number of k-points.
-     * @return {number[]} - Grid dimensions
+     * @return Grid dimensions
      */
-    getDimensionsFromPointsCount(nKpoints: number): number[];
+    getDimensionsFromPointsCount(nKpoints: number): Vector3DSchema;
     get conversionTable(): ConversionTable;
     /**
      * Calculate grid dimensions from k-point spacing, i.e.
@@ -77,9 +75,8 @@ export declare class ReciprocalLattice extends Lattice {
      * Note: just as the lattice vectors spacing is in cartesian (2pi / a) units by default
      * @param {number} spacing - maximum Spacing between k-points
      * @param {string} units - units of spacing parameter (default: 2pi / a)
-     * @return {number[]}
      */
-    getDimensionsFromSpacing(spacing: number, units?: string): number[];
+    getDimensionsFromSpacing(spacing: number, units?: string): Vector3DSchema;
     /**
      * Calculate grid spacing as average of spacing along individual reciprocal axes.
      * @param {number[]} dimensions - Array of dimensions

package/dist/js/lattice/reciprocal/lattice_reciprocal.js

@@ -5,8 +5,8 @@ var __importDefault = (this && this.__importDefault) || function (mod) {
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.ReciprocalLattice = void 0;
 const constants_1 = require("@mat3ra/code/dist/js/constants");
+const math_1 = require("@mat3ra/code/dist/js/math");
 const lodash_1 = __importDefault(require("lodash"));
-const math_1 = __importDefault(require("../../math"));
 const lattice_1 = require("../lattice");
 const paths_1 = require("./paths");
 const symmetry_points_1 = require("./symmetry_points");
@@ -17,28 +17,26 @@ class ReciprocalLattice extends lattice_1.Lattice {
      */
     get reciprocalVectors() {
         const vectors_ = this.vectors.vectorArrays;
-        const a = math_1.default.vlen(vectors_[0]);
-        const divider = math_1.default.multiply(vectors_[0], math_1.default.cross(vectors_[1], vectors_[2])) / a;
+        const a = math_1.math.vlen(vectors_[0]);
+        const divider = math_1.math.multiply(vectors_[0], math_1.math.cross(vectors_[1], vectors_[2])) / a;
         return [
-            math_1.default.multiply(math_1.default.cross(vectors_[1], vectors_[2]), 1 / divider),
-            math_1.default.multiply(math_1.default.cross(vectors_[2], vectors_[0]), 1 / divider),
-            math_1.default.multiply(math_1.default.cross(vectors_[0], vectors_[1]), 1 / divider),
+            math_1.math.multiply(math_1.math.cross(vectors_[1], vectors_[2]), 1 / divider),
+            math_1.math.multiply(math_1.math.cross(vectors_[2], vectors_[0]), 1 / divider),
+            math_1.math.multiply(math_1.math.cross(vectors_[0], vectors_[1]), 1 / divider),
         ];
     }
     /**
      * Norms of reciprocal vectors.
-     * @return {number[]}
      */
     get reciprocalVectorNorms() {
-        return this.reciprocalVectors.map((vec) => math_1.default.norm(vec));
+        return this.reciprocalVectors.map((vec) => math_1.math.norm(vec));
     }
     /**
      * Ratio of reciprocal vector norms scaled by the inverse of the largest component.
-     * @return {number[]}
      */
     get reciprocalVectorRatios() {
         const norms = this.reciprocalVectorNorms;
-        const maxNorm = math_1.default.max(...norms);
+        const maxNorm = math_1.math.max(...norms);
         return norms.map((n) => n / maxNorm);
     }
     /**
@@ -47,7 +45,7 @@ class ReciprocalLattice extends lattice_1.Lattice {
      * @return {KPointCoordinates}
      */
     getCartesianCoordinates(point) {
-        return math_1.default.multiply(point, this.reciprocalVectors);
+        return math_1.math.multiply(point, this.reciprocalVectors);
     }
     /**
      * Get the list of high-symmetry points for the current lattice.
@@ -74,7 +72,7 @@ class ReciprocalLattice extends lattice_1.Lattice {
         const symmPoints = this.symmetryPoints;
         dataPoints.forEach((point, index) => {
             const symmPoint = symmPoints.find((x) => {
-                return math_1.default.vEqualWithTolerance(x.coordinates, point, 1e-4);
+                return math_1.math.vEqualWithTolerance(x.coordinates, point, 1e-4);
             });
             if (symmPoint) {
                 kpointPath.push({
@@ -96,13 +94,13 @@ class ReciprocalLattice extends lattice_1.Lattice {
     calculateDimension(nPoints, index) {
         const norms = this.reciprocalVectorNorms;
         const [j, k] = [0, 1, 2].filter((i) => i !== index); // get indices of other two dimensions
-        const N = math_1.default.cbrt((nPoints * norms[index] ** 2) / (norms[j] * norms[k]));
-        return math_1.default.max(1, math_1.default.ceil(N));
+        const N = math_1.math.cbrt((nPoints * norms[index] ** 2) / (norms[j] * norms[k]));
+        return math_1.math.max(1, math_1.math.ceil(N));
     }
     /**
      * Calculate grid dimensions from total number of k-points.
      * @param {number} nKpoints - Total number of k-points.
-     * @return {number[]} - Grid dimensions
+     * @return Grid dimensions
      */
     getDimensionsFromPointsCount(nKpoints) {
         const indices = [0, 1, 2];
@@ -112,10 +110,10 @@ class ReciprocalLattice extends lattice_1.Lattice {
         const { a } = this;
         return {
             [constants_1.ATOMIC_COORD_UNITS.cartesian]: {
-                [constants_1.units.angstrom]: (2 * math_1.default.PI) / a,
+                [constants_1.units.angstrom]: (2 * math_1.math.PI) / a,
             },
             [constants_1.units.angstrom]: {
-                [constants_1.ATOMIC_COORD_UNITS.cartesian]: a / (2 * math_1.default.PI),
+                [constants_1.ATOMIC_COORD_UNITS.cartesian]: a / (2 * math_1.math.PI),
             },
         };
     }
@@ -125,12 +123,11 @@ class ReciprocalLattice extends lattice_1.Lattice {
      * Note: just as the lattice vectors spacing is in cartesian (2pi / a) units by default
      * @param {number} spacing - maximum Spacing between k-points
      * @param {string} units - units of spacing parameter (default: 2pi / a)
-     * @return {number[]}
      */
     getDimensionsFromSpacing(spacing, units = constants_1.ATOMIC_COORD_UNITS.cartesian) {
         const factor = this.conversionTable[units][constants_1.ATOMIC_COORD_UNITS.cartesian] || 1;
         return this.reciprocalVectorNorms.map((norm) => {
-            return math_1.default.max(1, math_1.default.ceil(lodash_1.default.round(norm / (spacing * factor), 4)));
+            return math_1.math.max(1, math_1.math.ceil(lodash_1.default.round(norm / (spacing * factor), 4)));
         });
     }
     /**
@@ -143,7 +140,7 @@ class ReciprocalLattice extends lattice_1.Lattice {
         const factor = this.conversionTable[constants_1.ATOMIC_COORD_UNITS.cartesian][units] || 1;
         const norms = this.reciprocalVectorNorms;
         return (factor *
-            math_1.default.mean(dimensions.map((dim, i) => norms[i] / math_1.default.max(1, dim))));
+            math_1.math.mean(dimensions.map((dim, i) => norms[i] / math_1.math.max(1, dim))));
     }
 }
 exports.ReciprocalLattice = ReciprocalLattice;