From 4005b08cda555179b671e571dad38a9129ef71f9 Mon Sep 17 00:00:00 2001 From: jobo322 Date: Thu, 8 Feb 2024 10:43:59 -0500 Subject: [PATCH] fix!: rename getSimilarity to treeSimilarity fix!: treeSimilarity only expects tree chore: treeSimilarity could accepts null because it is the way the method stops the recursive execution fix!: createTree expects a object {x,y} feat: add type structures chore: adapt README --- README.md | 16 +++-- package.json | 1 + src/__tests__/createTree.test.js | 4 +- src/__tests__/tree.test.js | 33 ++++------ ...ilarity.test.js => treeSimilarity.test.js} | 8 +-- src/createTree.js | 62 ++++++++----------- src/getSimilarity.js | 34 ---------- src/index.js | 11 +--- src/treeSimilarity.js | 42 +++++++++++++ types.d.ts | 45 ++++++++++++++ 10 files changed, 144 insertions(+), 112 deletions(-) rename src/__tests__/{getSimilarity.test.js => treeSimilarity.test.js} (57%) delete mode 100644 src/getSimilarity.js create mode 100644 src/treeSimilarity.js create mode 100644 types.d.ts diff --git a/README.md b/README.md index a68acd8..95de133 100644 --- a/README.md +++ b/README.md @@ -15,15 +15,21 @@ Compares two spectra using a tree similarity. ```js import { createTree, treeSimilarity } from 'ml-tree-similarity'; -const a = [[1, 2, 3, 4, 5, 6, 7], [0.3, 0.7, 4, 0.3, 0.2, 5, 0.3]]; -const b = [[1, 2, 3, 4, 5, 6, 7], [0.3, 4, 0.7, 0.3, 5, 0.2, 0.3]]; +const a = { + x: [1, 2, 3, 4, 5, 6, 7], + y: [0.3, 0.7, 4, 0.3, 0.2, 5, 0.3], +}; +const b = { + x: [1, 2, 3, 4, 5, 6, 7], + y: [0.3, 4, 0.7, 0.3, 5, 0.2, 0.3], +}; // create a tree const options = { from: 1, to: 7 }; -const A = createTree(a, options); +const aTree = createTree(a, options); +const bTree = createTree(b, options); -// a pre-calculated tree is also a valid input -const ans = treeSimilarity(A, b, options); +const ans = treeSimilarity(aTree, bTree, options); ``` ## [API Documentation](https://mljs.github.io/tree-similarity/) diff --git a/package.json b/package.json index 7011d91..77639b0 100644 --- a/package.json +++ b/package.json @@ -40,6 +40,7 @@ }, "dependencies": { "binary-search": "^1.3.6", + "cheminfo-types": "^1.7.2", "num-sort": "^3.0.0" } } diff --git a/src/__tests__/createTree.test.js b/src/__tests__/createTree.test.js index 2fa6565..98e1a4c 100644 --- a/src/__tests__/createTree.test.js +++ b/src/__tests__/createTree.test.js @@ -6,7 +6,7 @@ describe('simple trees', () => { it('two peaks, same height', () => { let x = [0, 1, 2, 3, 4, 5, 6, 7, 8, 9, 10]; let y = [0, 0, 0, 1, 0, 0, 0, 1, 0, 0, 0]; - let tree = createTree([x, y]); + let tree = createTree({ x, y }); expect(tree.center).toBe(5); expect(tree.sum).toBe(2); @@ -34,7 +34,7 @@ describe('simple trees', () => { y[20] = 20; y[80] = 20; - let tree = createTree([x, y]); + let tree = createTree({ x, y }); expect(tree.center).toBe(50); expect(tree.sum).toBe(40); diff --git a/src/__tests__/tree.test.js b/src/__tests__/tree.test.js index add3765..b11337f 100644 --- a/src/__tests__/tree.test.js +++ b/src/__tests__/tree.test.js @@ -1,28 +1,21 @@ import { describe, it, expect } from 'vitest'; -import { treeSimilarity, getFunction } from '..'; +import { createTree, treeSimilarity } from '../index'; -let a = [ - [1, 2, 3, 4, 5, 6, 7], - [0.3, 0.7, 4, 0.3, 0.2, 5, 0.3], -]; -let b = [ - [1, 2, 3, 4, 5, 6, 7], - [0.3, 4, 0.7, 0.3, 5, 0.2, 0.3], -]; +const a = { + x: [1, 2, 3, 4, 5, 6, 7], + y: [0.3, 0.7, 4, 0.3, 0.2, 5, 0.3], +}; +const b = { + x: [1, 2, 3, 4, 5, 6, 7], + y: [0.3, 4, 0.7, 0.3, 5, 0.2, 0.3], +}; describe('Tree similarity', () => { it('should work with two arrays', () => { - expect(treeSimilarity(a, b)).toBeCloseTo(0.653354, 4); - }); - - it('should currify the options', () => { - let options = { - alpha: 0.4, - beta: 0.5, - gamma: 0.001, - }; - let func = getFunction(options); - expect(func(a, b)).toBe(treeSimilarity(a, b, options)); + expect(treeSimilarity(createTree(a), createTree(b))).toBeCloseTo( + 0.653354, + 4, + ); }); }); diff --git a/src/__tests__/getSimilarity.test.js b/src/__tests__/treeSimilarity.test.js similarity index 57% rename from src/__tests__/getSimilarity.test.js rename to src/__tests__/treeSimilarity.test.js index a00bbaa..620bc4c 100644 --- a/src/__tests__/getSimilarity.test.js +++ b/src/__tests__/treeSimilarity.test.js @@ -1,15 +1,15 @@ import { describe, it, expect } from 'vitest'; import { createTree } from '../createTree'; -import { getSimilarity } from '../getSimilarity'; +import { treeSimilarity } from '../treeSimilarity'; describe('simple trees', () => { it('same tree', () => { let x = [0, 1, 2, 3, 4, 5, 6, 7, 8, 9, 10]; let y = [0, 0, 0, 1, 0, 0, 0, 1, 0, 0, 0]; - let tree1 = createTree([x, y]); - let tree2 = createTree([x, y]); + let tree1 = createTree({ x, y }); + let tree2 = createTree({ x, y }); - expect(getSimilarity(tree1, tree2, { beta: 1 })).toBe(1); + expect(treeSimilarity(tree1, tree2, { beta: 1 })).toBe(1); }); }); diff --git a/src/createTree.js b/src/createTree.js index b5aec36..2aae7f0 100644 --- a/src/createTree.js +++ b/src/createTree.js @@ -1,40 +1,37 @@ import binarySearch from 'binary-search'; import { numberSortAscending } from 'num-sort'; +/** + * @typedef {import("../types").Tree} Tree + * @typedef {import("../types").CreateTreeOptions} CreateTreeOptions + * @typedef {import("../types").Spectrum} Spectrum + */ + /** * Function that creates the tree - * @param {Array>} spectrum - * @param {object} [options] - * @return {Tree|null} - * left and right have the same structure than the parent, - * or are null if they are leaves + * @param {Spectrum} spectrum + * @param {CreateTreeOptions} [options] + * @return { Tree | null } */ export function createTree(spectrum, options = {}) { - const X = spectrum[0]; + const { x, y } = spectrum; const { minWindow = 0.16, threshold = 0.01, - from = X[0], - to = X[X.length - 1], + from = x[0], + to = x[x.length - 1], } = options; - return mainCreateTree( - spectrum[0], - spectrum[1], - from, - to, - minWindow, - threshold, - ); + return mainCreateTree(x, y, from, to, minWindow, threshold); } -function mainCreateTree(X, Y, from, to, minWindow, threshold) { +function mainCreateTree(x, y, from, to, minWindow, threshold) { if (to - from < minWindow) { return null; } // search first point - let start = binarySearch(X, from, numberSortAscending); + let start = binarySearch(x, from, numberSortAscending); if (start < 0) { start = ~start; } @@ -42,12 +39,12 @@ function mainCreateTree(X, Y, from, to, minWindow, threshold) { // stop at last point let sum = 0; let center = 0; - for (let i = start; i < X.length; i++) { - if (X[i] >= to) { + for (let i = start; i < x.length; i++) { + if (x[i] >= to) { break; } - sum += Y[i]; - center += X[i] * Y[i]; + sum += y[i]; + center += x[i] * y[i]; } if (sum < threshold) { @@ -59,24 +56,15 @@ function mainCreateTree(X, Y, from, to, minWindow, threshold) { return null; } if (center - from < minWindow / 4) { - return mainCreateTree(X, Y, center, to, minWindow, threshold); + return mainCreateTree(x, y, center, to, minWindow, threshold); } else if (to - center < minWindow / 4) { - return mainCreateTree(X, Y, from, center, minWindow, threshold); + return mainCreateTree(x, y, from, center, minWindow, threshold); } else { - return new Tree( + return { sum, center, - mainCreateTree(X, Y, from, center, minWindow, threshold), - mainCreateTree(X, Y, center, to, minWindow, threshold), - ); - } -} - -class Tree { - constructor(sum, center, left, right) { - this.sum = sum; - this.center = center; - this.left = left; - this.right = right; + left: mainCreateTree(x, y, from, center, minWindow, threshold), + right: mainCreateTree(x, y, center, to, minWindow, threshold), + }; } } diff --git a/src/getSimilarity.js b/src/getSimilarity.js deleted file mode 100644 index 0d22228..0000000 --- a/src/getSimilarity.js +++ /dev/null @@ -1,34 +0,0 @@ -import { createTree } from './createTree'; - -/** - * Similarity between two nodes - * @param {Tree|Array>} a - tree A node - * @param {Tree|Array>} b - tree B node - * @param {object} [options] - * @return {number} similarity measure between tree nodes - */ -export function getSimilarity(a, b, options = {}) { - const { alpha = 0.1, beta = 0.33, gamma = 0.001 } = options; - - if (a === null || b === null) { - return 0; - } - if (Array.isArray(a)) { - a = createTree(a); - } - if (Array.isArray(b)) { - b = createTree(b); - } - - const C = - (alpha * Math.min(a.sum, b.sum)) / Math.max(a.sum, b.sum) + - (1 - alpha) * Math.exp(-gamma * Math.abs(a.center - b.center)); - - return ( - beta * C + - ((1 - beta) * - (getSimilarity(a.left, b.left, options) + - getSimilarity(a.right, b.right, options))) / - 2 - ); -} diff --git a/src/index.js b/src/index.js index 09db3e5..86b8d7d 100644 --- a/src/index.js +++ b/src/index.js @@ -1,11 +1,2 @@ -import { getSimilarity } from './getSimilarity'; - +export { treeSimilarity } from './treeSimilarity'; export { createTree } from './createTree'; - -export function treeSimilarity(A, B, options = {}) { - return getSimilarity(A, B, options); -} - -export function getFunction(options = {}) { - return (A, B) => getSimilarity(A, B, options); -} diff --git a/src/treeSimilarity.js b/src/treeSimilarity.js new file mode 100644 index 0000000..77cc03c --- /dev/null +++ b/src/treeSimilarity.js @@ -0,0 +1,42 @@ +/** + * @typedef {import("../types").Tree} Tree + * @typedef {import("../types").TreeSimilarityOptions} TreeSimilarityOptions + */ +/** + * Similarity between two nodes + * @param {Tree | null} a - tree A node + * @param {Tree | null} b - tree B node + * @param {TreeSimilarityOptions} [options] + * @return {number} similarity measure between tree nodes + */ +export function treeSimilarity(a, b, options = {}) { + const { alpha = 0.1, beta = 0.33, gamma = 0.001 } = options; + + if (a === null || b === null) { + return 0; + } + + if (!isTree(a) || !isTree(b)) { + throw new Error('tree similarity expects tree as inputs'); + } + + if (a.sum === 0 && b.sum === 0) { + return 1; + } + + const C = + (alpha * Math.min(a.sum, b.sum)) / Math.max(a.sum, b.sum) + + (1 - alpha) * Math.exp(-gamma * Math.abs(a.center - b.center)); + + return ( + beta * C + + ((1 - beta) * + (treeSimilarity(a.left, b.left, options) + + treeSimilarity(a.right, b.right, options))) / + 2 + ); +} + +function isTree(a) { + return ['sum', 'center', 'left', 'right'].every((key) => key in a); +} diff --git a/types.d.ts b/types.d.ts new file mode 100644 index 0000000..12c537e --- /dev/null +++ b/types.d.ts @@ -0,0 +1,45 @@ +import { NumberArray } from "cheminfo-types"; + +export interface Tree { + sum: number; + center: number; + /** + * left and right have the same structure than the parent, + * or are null if they are leaves + */ + left: Tree | null; + right: Tree | null; +} + +export interface CreateTreeOptions { + /** + * low limit of the tree + * @default x[0] + */ + from?: number + /** + * high limit of the tree + * @default x.at(-1) + */ + to?: number + /** + * minimal sum value to accept a node + * @default 0.01 + */ + threshold?: number; + /** + * minimal window width to create a node + * @default 0.16 + */ + minWindow?: number +} + +export interface TreeSimilarityOptions { + alpha?: number; + beta?: number; + gamma?: number; +} +export interface Spectrum { + x: NumberArray; + y: NumberArray; +} \ No newline at end of file