Merge pull request #7 from Exabyte-io/chore/SOF-6008

Chore/sof 6008 - add utils

Author: timurbazhirov

package.json

@@ -44,6 +44,7 @@
         "@babel/runtime-corejs3": "7.16.8",
         "crypto-js": "^4.1.1",
         "lodash": "^4.17.21",
+        "mathjs": "^3.9.0",
         "mixwith": "^0.1.1",
         "underscore": "^1.13.3"
     },

src/constants.js

@@ -0,0 +1,39 @@
+export const coefficients = {
+    EV_TO_RY: 0.0734986176,
+    BOHR_TO_ANGSTROM: 0.52917721092,
+    ANGSTROM_TO_BOHR: 1 / 0.52917721092,
+    EV_A_TO_RY_BOHR: 1 / 25.71104309541616,
+};
+
+export const tolerance = {
+    // in crystal coordinates
+    length: 0.01,
+    lengthAngstrom: 0.001,
+    pointsDistance: 0.001,
+};
+
+export const units = {
+    bohr: "bohr",
+    angstrom: "angstrom",
+    degree: "degree",
+    radian: "radian",
+    alat: "alat",
+};
+
+/**
+ * @summary Coordinates units for a material's basis.
+ */
+export const ATOMIC_COORD_UNITS = {
+    crystal: "crystal",
+    cartesian: "cartesian",
+};
+
+// Only 3 digits will be considered for lattice and basis params on hashing
+export const HASH_TOLERANCE = 3;
+
+export default {
+    coefficients,
+    tolerance,
+    units,
+    ATOMIC_COORD_UNITS,
+};

src/entity/in_memory.js

@@ -109,6 +109,9 @@ export class InMemoryEntity {
 
     get cls() {return this.constructor.name}
 
+    // TODO: figure out why the above getter for `cls` returns `null` and use only one
+    getClsName() {return this.constructor.name}
+
     get slug() {return this.prop('slug')}
 
     get isSystemEntity() {
@@ -127,7 +130,7 @@ export class InMemoryEntity {
         return {
             _id: this.id,
             slug: this.slug,
-            cls: this.cls,
+            cls: this.getClsName(),
         }
     }
 

src/entity/index.js

@@ -3,6 +3,7 @@ import {
 } from "./in_memory";
 
 import {
+    NamedInMemoryEntity,
     DefaultableInMemoryEntity,
     NamedDefaultableInMemoryEntity,
     HasMetadataNamedDefaultableInMemoryEntity,
@@ -16,6 +17,7 @@ import {
     NamedEntityMixin,
 } from "./mixins";
 
+import { InMemoryEntitySet } from "./set";
 import { ENTITY_SET_TYPES } from "./set/enums";
 
 import { constructEntitySetFactoryByConfig } from "./set/factory";
@@ -26,6 +28,7 @@ import { OrderedInMemoryEntityInSetMixin, OrderedInMemoryEntitySetMixin } from "
 export {
 
     InMemoryEntity,
+    NamedInMemoryEntity,
     DefaultableInMemoryEntity,
     NamedDefaultableInMemoryEntity,
     HasMetadataNamedDefaultableInMemoryEntity,
@@ -36,6 +39,7 @@ export {
     TaggableMixin,
     NamedEntityMixin,
 
+    InMemoryEntitySet,
     ENTITY_SET_TYPES,
     constructEntitySetFactoryByConfig,
     selectorsForEntitySet,

src/entity/other.js

@@ -6,6 +6,12 @@ export class DefaultableInMemoryEntity extends mix(InMemoryEntity).with(
     DefaultableMixin
 ) {
 
+}
+
+export class NamedInMemoryEntity extends mix(InMemoryEntity).with(
+    NamedEntityMixin
+) {
+
 }
 export class NamedDefaultableInMemoryEntity extends mix(InMemoryEntity).with(
     DefaultableMixin,

src/entity/set.js

@@ -2,14 +2,12 @@ import _ from "underscore";
 import {mix} from "mixwith";
 
 import { InMemoryEntity } from "./in_memory";
-import {NamedEntityMixin, TaggableMixin } from "./mixins";
 import {InMemoryEntitySetMixin, InMemoryEntityInSetMixin } from "./set/mixins";
 
 export class InMemoryEntitySet extends mix(InMemoryEntity).with(
     InMemoryEntitySetMixin,
     InMemoryEntityInSetMixin,
-    NamedEntityMixin,
-    TaggableMixin,
+
 ) {
 
     get isEntitySet() {return this.prop('isEntitySet')}
@@ -18,7 +16,7 @@ export class InMemoryEntitySet extends mix(InMemoryEntity).with(
 
     get entityCls() {return this.prop('entityCls')}
 
-    get cls() {return this.entityCls}
+    get cls() {return this.entityCls || super.cls}
 
     toJSONForInclusionInEntity() {
         return _.pick(this.toJSON(), ['_id', 'type']);

src/math.js

@@ -0,0 +1,257 @@
+import _ from "underscore";
+import mathjs from "mathjs";
+
+import { tolerance as TOLERANCE } from "./constants";
+
+/**
+ * @summary Zero threshold. Numbers below it are put to zero exactly.
+ * Used to avoid math.js bug in treating zero as X.XXe-16.
+ */
+const EPSILON = 1e-8;
+/**
+ * @summary Returns scalar product of vectors
+ * @param v1 {Number[]} Vector 1
+ * @param v2 {Number[]} Vector 2
+ * @return {Number}
+ */
+
+const product = (v1, v2) => {
+    return math.multiply(v1, math.transpose(v2));
+};
+
+/**
+ * @summary Returns length of a vector.
+ * @param v {Number[]} Vector
+ * @return {Number}
+ */
+const vlen = (v) => {
+    return math.sqrt(product(v, v));
+};
+
+/**
+ * @summary Returns angle between `a` and `b` vectors.
+ * @param a {Number[]} Vector a
+ * @param b {Number[]} Vector b
+ * @param [unit] {String} `rad`, `deg`
+ * @return {Number}
+ */
+const angle = (a, b, unit) => {
+    const lenA = vlen(a);
+    const lenB = vlen(b);
+    return math.unit(math.acos(product(a, b) / (lenA * lenB)), "rad").toNumber(unit || "deg");
+};
+
+const angleUpTo90 = (...args) => {
+    const angleUpTo180 = angle(...args);
+    return angleUpTo180 < 90 ? angleUpTo180 : 180 - angleUpTo180;
+};
+
+/**
+ * @summary Returns distance between 2 vectors.
+ * @param v1 {Number[]} Vector
+ * @param v2 {Number[]} Vector
+ * @return {Number}
+ */
+const vDist = (v1, v2) => {
+    if (v1.length !== v2.length) {
+        console.error(
+            "Attempting to calculate distance between vectors of different dimensionality",
+        );
+        return;
+    }
+    return vlen(v1.map((coordinate, index) => coordinate - v2[index]));
+};
+
+/**
+ * @summary Returns checks whether 2 vector are equal within tolerance.
+ * @param vec1 {Number[]} Vector
+ * @param vec2 {Number[]} Vector
+ * @param tolerance {Number} Tolerance
+ * @return {Number}
+ */
+const vEqualWithTolerance = (vec1, vec2, tolerance = TOLERANCE.pointsDistance) =>
+    vDist(vec1, vec2) <= tolerance;
+
+/**
+ * @summary Returns 0 if passed number is less than Made.math.EPSILON.
+ * @param n {Number}
+ * @return {Number}
+ */
+const roundToZero = (n) => {
+    return Math.abs(n) < EPSILON ? 0 : n;
+};
+
+/**
+ * @summary Returns number with specified precision.
+ * @param x {Number}
+ * @param n {Number}
+ * @return {Number}
+ */
+const precise = (x, n = 7) => {
+    return Number(x.toPrecision(n));
+};
+
+/**
+ * @summary Returns mod of the passed value with the specified tolerance.
+ * @param num {Number}
+ * @param tolerance {Number}
+ * @return {Number}
+ */
+const mod = (num, tolerance = 0.001) => {
+    const m = num % 1;
+    const x = num >= 0 ? m : 1 + m;
+
+    if (math.smallerEq(Math.abs(x - 1), tolerance) || math.smallerEq(Math.abs(x), tolerance)) {
+        return 0;
+    }
+    return x;
+};
+
+/**
+ * @summary Returns cartesian of passed arrays.
+ * @example combinations([1,2], [4,5], [6]) = [[1,4,6], [1,5,6], [2,4,6], [2,5,6]];
+ */
+const cartesianProduct = (...arg) => {
+    const r = [];
+    const max = arg.length - 1;
+
+    const helper = (arr, i) => {
+        for (let j = 0, l = arg[i].length; j < l; j++) {
+            const a = arr.slice(0); // clone arr
+            a.push(arg[i][j]);
+            if (i === max) {
+                r.push(a);
+            } else {
+                helper(a, i + 1);
+            }
+        }
+    };
+
+    helper([], 0);
+    return r;
+};
+
+/**
+ * @summary Returns all possible positive integer combinations where each value changes from 0 to a, b, c.
+ * @param a {Number}
+ * @param b {Number}
+ * @param tolerance {Number}
+ */
+const almostEqual = (a, b, tolerance = TOLERANCE.pointsDistance) => {
+    return Math.abs(a - b) < tolerance;
+};
+
+/**
+ * @summary Returns true if number is 0 <= x < 1, inclusive, otherwise false.
+ * Helper to deal with JS arithmetic artifacts.
+ * @number number {Number}
+ */
+const isBetweenZeroInclusiveAndOne = (number, tolerance = TOLERANCE.length) => {
+    return roundToZero(number) >= 0 && !almostEqual(number, 1, tolerance) && number < 1;
+};
+
+/**
+ * @summary Returns all possible positive integer combinations where each value changes from 0 to a, b, c.
+ * @example
+ *   var comb = combinations(1, 2, 0);
+ *   // [[0, 0, 0], [0, 1, 0], [0, 2, 0], [1, 0, 0], [1, 1, 0], [1, 2, 0]]
+ * @param a
+ * @param b
+ * @param c
+ */
+const combinations = (a, b, c) => {
+    const combs = [];
+    for (let i = 0; i <= a; i++) {
+        for (let j = 0; j <= b; j++) {
+            for (let k = 0; k <= c; k++) {
+                combs.push([i, j, k]);
+            }
+        }
+    }
+    return combs;
+};
+
+/*
+ * @summary Same as `combinations` but accepting intervals (tuples) of integers: eg. [-3, 4]
+ */
+const combinationsFromIntervals = (arrA, arrB, arrC) => {
+    const combs = [];
+    for (let i = arrA[0]; i <= arrA[1]; i++) {
+        for (let j = arrB[0]; j <= arrB[1]; j++) {
+            for (let k = arrC[0]; k <= arrC[1]; k++) {
+                combs.push([i, j, k]);
+            }
+        }
+    }
+    return combs;
+};
+
+const roundValueToNDecimals = (value, decimals = 3) => {
+  return parseFloat(value.toFixed(decimals));
+}
+
+/**
+ * @summary Returns n splits of the passed segment.
+ * @param point1 {Number[]}
+ * @param point2 {Number[]}
+ * @param n {Number}
+ */
+const calculateSegmentsBetweenPoints3D = (point1, point2, n) => {
+    // safely parse if passed strings
+    const point1_ = point1.map(x => parseFloat(x));
+    const point2_ = point2.map(x => parseFloat(x));
+    const n_ = parseInt(n)
+
+    const result = [];
+    for (let i = 1; i < n_; i++) {
+        const lambda = i / (n_ - i);
+        result.push([
+            (point1_[0] + lambda * point2_[0]) / (1 + lambda),
+            (point1_[1] + lambda * point2_[1]) / (1 + lambda),
+            (point1_[2] + lambda * point2_[2]) / (1 + lambda)
+        ]);
+    }
+    return result;
+}
+
+/**
+ * @summary Wrapper for native [Number.toPrecision](https://developer.mozilla.org/en/docs/Web/JavaScript/Reference/Global_objects/Number/toPrecision) method.
+ * Returns a string representing the Number object to the specified precision.
+ * @memberOf Helpers
+ * @package exabyte:core
+ * @locus Client
+ * @method
+ * @name toPrecision
+ * @param {Number} number
+ * @param {Number} precision Optional. An integer specifying the number of significant digits.
+ */
+export function numberToPrecision(number, precision) {
+
+    if (_.isNumber(number)) {
+        return number.toPrecision(precision);
+    }
+    return number;
+}
+
+export const math = {
+    ...mathjs,
+    PI: Math.PI,
+    trunc: Math.trunc,
+    product,
+    vlen,
+    angle,
+    angleUpTo90,
+    vDist,
+    vEqualWithTolerance,
+    roundToZero,
+    precise,
+    mod,
+    isBetweenZeroInclusiveAndOne,
+    cartesianProduct,
+    almostEqual,
+    combinations,
+    combinationsFromIntervals,
+    calculateSegmentsBetweenPoints3D,
+    roundValueToNDecimals,
+    numberToPrecision,
+};