@mat3ra/made 2026.5.21-2 → 2026.6.11-0

package/constants.json

@@ -0,0 +1,13 @@
+{
+  "molecule": {
+    "nonPeriodicMinimumLatticeSize": 3.0,
+    "diatomicLatticePaddingFactor": 3.0,
+    "molecularLatticePaddingFactor": 2.0
+  },
+  "precision": {
+    "coordinatesCrystal": 9,
+    "coordinatesCartesian": 6,
+    "latticeLengths": 6,
+    "latticeAngles": 4
+  }
+}

package/dist/js/basis/basis.d.ts

@@ -147,11 +147,12 @@ export declare class Basis extends InMemoryEntity implements BasisSchema {
      */
     hasEquivalentCellTo(anotherBasisClsInstance: Basis): boolean;
     /**
-     * @summary function returns the minimum basis lattice size for a structure.
-     * The lattice size is based on the atomic radius of an element if the basis contains a single atom.
-     * The lattice size is based on the maximum pairwise distance across a structure if the basis contains > 2 atoms.
+     * @summary Returns the minimum cubic lattice size for a non-periodic structure.
+     * Single-atom structures use the element atomic radius floored at defaultMinimumLatticeSize.
+     * Multi-atom structures scale the maximum pairwise distance by 3 when W=min/max pairwise distance
+     * is ~1 (diatomic), otherwise by 2.
      */
-    getMinimumLatticeSize(latticeScalingFactor?: number): number;
+    getMinimumLatticeSize(defaultMinimumLatticeSize?: number): number;
     /**
      * @summary function returns an array of overlapping atoms within specified tolerance.
      */
@@ -172,6 +173,8 @@ export declare class Basis extends InMemoryEntity implements BasisSchema {
      *
      */
     get maxPairwiseDistance(): number;
+    get minPairwiseDistance(): number;
+    getPairwiseDistanceExtremum(extremum: "max" | "min"): number;
     /**
      * @summary Function takes basis coordinates and transposes them so that the values for each dimension of the
      *  the basis are in their own nested array.

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,24 +361,30 @@ 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);
     }
     /**
-     * @summary function returns the minimum basis lattice size for a structure.
-     * The lattice size is based on the atomic radius of an element if the basis contains a single atom.
-     * The lattice size is based on the maximum pairwise distance across a structure if the basis contains > 2 atoms.
+     * @summary Returns the minimum cubic lattice size for a non-periodic structure.
+     * Single-atom structures use the element atomic radius floored at defaultMinimumLatticeSize.
+     * Multi-atom structures scale the maximum pairwise distance by 3 when W=min/max pairwise distance
+     * is ~1 (diatomic), otherwise by 2.
      */
-    getMinimumLatticeSize(latticeScalingFactor = lattice_1.nonPeriodicLatticeScalingFactor) {
-        let latticeSizeAdditiveContribution = 0;
+    getMinimumLatticeSize(defaultMinimumLatticeSize = lattice_1.defaultNonPeriodicMinimumLatticeSize) {
         if (this._elements.values.length === 1) {
             const elementSymbol = this._elements.getElementValueByIndex(0);
-            latticeSizeAdditiveContribution = (0, periodic_table_js_1.getElementAtomicRadius)(elementSymbol);
+            const atomicRadius = (0, periodic_table_js_1.getElementAtomicRadius)(elementSymbol);
+            return Math.max(defaultMinimumLatticeSize, atomicRadius);
         }
-        const moleculeLatticeSize = this.maxPairwiseDistance * latticeScalingFactor;
-        const latticeSize = latticeSizeAdditiveContribution + moleculeLatticeSize;
-        return latticeSize;
+        const maxDistance = this.maxPairwiseDistance;
+        const minDistance = this.minPairwiseDistance;
+        const widthRatio = maxDistance > 0 ? minDistance / maxDistance : 1;
+        const latticeScalingFactor = math_1.math.almostEqual(widthRatio, 1)
+            ? lattice_1.diatomicLatticePaddingFactor
+            : lattice_1.molecularLatticePaddingFactor;
+        const moleculeLatticeSize = maxDistance * latticeScalingFactor;
+        return Math.max(defaultMinimumLatticeSize, moleculeLatticeSize);
     }
     /**
      * @summary function returns an array of overlapping atoms within specified tolerance.
@@ -401,7 +404,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,
@@ -431,22 +434,33 @@ class Basis extends entity_1.InMemoryEntity {
      *
      */
     get maxPairwiseDistance() {
+        return this.getPairwiseDistanceExtremum("max");
+    }
+    get minPairwiseDistance() {
+        return this.getPairwiseDistanceExtremum("min");
+    }
+    getPairwiseDistanceExtremum(extremum) {
         const originalUnits = this.units;
         this.toCartesian();
-        let maxDistance = 0;
+        let resultDistance = extremum === "max" ? 0 : Infinity;
         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));
-                    if (distance && distance > maxDistance) {
-                        maxDistance = distance;
+                    const distance = math_1.math.vDist(this._coordinates.getElementValueByIndex(i), this._coordinates.getElementValueByIndex(j));
+                    if (!distance)
+                        continue;
+                    if (extremum === "max" && distance > resultDistance) {
+                        resultDistance = distance;
+                    }
+                    if (extremum === "min" && distance < resultDistance) {
+                        resultDistance = distance;
                     }
                 }
             }
         }
         if (originalUnits !== constants_1.ATOMIC_COORD_UNITS.cartesian)
             this.toCrystal();
-        return maxDistance;
+        return extremum === "min" && resultDistance === Infinity ? 0 : resultDistance;
     }
     /**
      * @summary Function takes basis coordinates and transposes them so that the values for each dimension of the

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/constants/molecule.d.ts

@@ -0,0 +1,16 @@
+/**
+ * Constants for molecule handling and precision.
+ * Source of truth: /constants.json at repository root
+ *
+ * These values are duplicated here for TypeScript compilation.
+ * When updating these, also update constants.json.
+ */
+export declare const defaultNonPeriodicMinimumLatticeSize = 3;
+export declare const diatomicLatticePaddingFactor = 3;
+export declare const molecularLatticePaddingFactor = 2;
+export declare const PRECISION_MAP: {
+    coordinatesCrystal: number;
+    coordinatesCartesian: number;
+    latticeLengths: number;
+    latticeAngles: number;
+};

package/dist/js/constants/molecule.js

@@ -0,0 +1,19 @@
+"use strict";
+/**
+ * Constants for molecule handling and precision.
+ * Source of truth: /constants.json at repository root
+ *
+ * These values are duplicated here for TypeScript compilation.
+ * When updating these, also update constants.json.
+ */
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.PRECISION_MAP = exports.molecularLatticePaddingFactor = exports.diatomicLatticePaddingFactor = exports.defaultNonPeriodicMinimumLatticeSize = void 0;
+exports.defaultNonPeriodicMinimumLatticeSize = 3.0;
+exports.diatomicLatticePaddingFactor = 3.0;
+exports.molecularLatticePaddingFactor = 2.0;
+exports.PRECISION_MAP = {
+    coordinatesCrystal: 9,
+    coordinatesCartesian: 6,
+    latticeLengths: 6,
+    latticeAngles: 4,
+};

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

@@ -6,7 +6,7 @@ import { UnitCell } from "./unit_cell";
  * 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.
  */
-export declare const nonPeriodicLatticeScalingFactor = 2;
+export { defaultNonPeriodicMinimumLatticeSize, diatomicLatticePaddingFactor, molecularLatticePaddingFactor, } from "../constants/molecule";
 export declare class LatticeVectors extends Cell implements LatticeVectorsSchema {
 }
 export type { LatticeVectorsSchema };

package/dist/js/lattice/lattice.js

@@ -22,24 +22,24 @@ 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;
+exports.Lattice = exports.LatticeVectors = exports.molecularLatticePaddingFactor = exports.diatomicLatticePaddingFactor = exports.defaultNonPeriodicMinimumLatticeSize = 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");
 /**
  * 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.
  */
-exports.nonPeriodicLatticeScalingFactor = 2.0;
+var molecule_1 = require("../constants/molecule");
+Object.defineProperty(exports, "defaultNonPeriodicMinimumLatticeSize", { enumerable: true, get: function () { return molecule_1.defaultNonPeriodicMinimumLatticeSize; } });
+Object.defineProperty(exports, "diatomicLatticePaddingFactor", { enumerable: true, get: function () { return molecule_1.diatomicLatticePaddingFactor; } });
+Object.defineProperty(exports, "molecularLatticePaddingFactor", { enumerable: true, get: function () { return molecule_1.molecularLatticePaddingFactor; } });
 class LatticeVectors extends cell_1.Cell {
 }
 exports.LatticeVectors = LatticeVectors;
@@ -69,17 +69,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 +94,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 +144,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 +179,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 +224,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;