@langchain/core 0.3.72 → 1.0.0-alpha.2

package/dist/utils/math.cjs

@@ -1,126 +1,130 @@
-"use strict";
-Object.defineProperty(exports, "__esModule", { value: true });
-exports.matrixFunc = matrixFunc;
-exports.normalize = normalize;
-exports.cosineSimilarity = cosineSimilarity;
-exports.innerProduct = innerProduct;
-exports.euclideanDistance = euclideanDistance;
-exports.maximalMarginalRelevance = maximalMarginalRelevance;
-const similarities_js_1 = require("./ml-distance/similarities.cjs");
-const distances_js_1 = require("./ml-distance/distances.cjs");
-const euclidean_js_1 = require("./ml-distance-euclidean/euclidean.cjs");
+const require_rolldown_runtime = require('../_virtual/rolldown_runtime.cjs');
+const require_similarities = require('./ml-distance/similarities.cjs');
+const require_distances = require('./ml-distance/distances.cjs');
+const require_euclidean = require('./ml-distance-euclidean/euclidean.cjs');
+
+//#region src/utils/math.ts
+var math_exports = {};
+require_rolldown_runtime.__export(math_exports, {
+	cosineSimilarity: () => cosineSimilarity,
+	euclideanDistance: () => euclideanDistance,
+	innerProduct: () => innerProduct$1,
+	matrixFunc: () => matrixFunc,
+	maximalMarginalRelevance: () => maximalMarginalRelevance,
+	normalize: () => normalize
+});
 /**
- * Apply a row-wise function between two matrices with the same number of columns.
- *
- * @param {number[][]} X - The first matrix.
- * @param {number[][]} Y - The second matrix.
- * @param {VectorFunction} func - The function to apply.
- *
- * @throws {Error} If the number of columns in X and Y are not the same.
- *
- * @returns {number[][] | [[]]} A matrix where each row represents the result of applying the function between the corresponding rows of X and Y.
- */
+* Apply a row-wise function between two matrices with the same number of columns.
+*
+* @param {number[][]} X - The first matrix.
+* @param {number[][]} Y - The second matrix.
+* @param {VectorFunction} func - The function to apply.
+*
+* @throws {Error} If the number of columns in X and Y are not the same.
+*
+* @returns {number[][] | [[]]} A matrix where each row represents the result of applying the function between the corresponding rows of X and Y.
+*/
 function matrixFunc(X, Y, func) {
-    if (X.length === 0 ||
-        X[0].length === 0 ||
-        Y.length === 0 ||
-        Y[0].length === 0) {
-        return [[]];
-    }
-    if (X[0].length !== Y[0].length) {
-        throw new Error(`Number of columns in X and Y must be the same. X has shape ${[
-            X.length,
-            X[0].length,
-        ]} and Y has shape ${[Y.length, Y[0].length]}.`);
-    }
-    return X.map((xVector) => Y.map((yVector) => func(xVector, yVector)).map((similarity) => Number.isNaN(similarity) ? 0 : similarity));
+	if (X.length === 0 || X[0].length === 0 || Y.length === 0 || Y[0].length === 0) return [[]];
+	if (X[0].length !== Y[0].length) throw new Error(`Number of columns in X and Y must be the same. X has shape ${[X.length, X[0].length]} and Y has shape ${[Y.length, Y[0].length]}.`);
+	return X.map((xVector) => Y.map((yVector) => func(xVector, yVector)).map((similarity) => Number.isNaN(similarity) ? 0 : similarity));
 }
 function normalize(M, similarity = false) {
-    const max = matrixMaxVal(M);
-    return M.map((row) => row.map((val) => (similarity ? 1 - val / max : val / max)));
+	const max = matrixMaxVal(M);
+	return M.map((row) => row.map((val) => similarity ? 1 - val / max : val / max));
 }
 /**
- * This function calculates the row-wise cosine similarity between two matrices with the same number of columns.
- *
- * @param {number[][]} X - The first matrix.
- * @param {number[][]} Y - The second matrix.
- *
- * @throws {Error} If the number of columns in X and Y are not the same.
- *
- * @returns {number[][] | [[]]} A matrix where each row represents the cosine similarity values between the corresponding rows of X and Y.
- */
+* This function calculates the row-wise cosine similarity between two matrices with the same number of columns.
+*
+* @param {number[][]} X - The first matrix.
+* @param {number[][]} Y - The second matrix.
+*
+* @throws {Error} If the number of columns in X and Y are not the same.
+*
+* @returns {number[][] | [[]]} A matrix where each row represents the cosine similarity values between the corresponding rows of X and Y.
+*/
 function cosineSimilarity(X, Y) {
-    return matrixFunc(X, Y, similarities_js_1.cosine);
+	return matrixFunc(X, Y, require_similarities.cosine);
 }
-function innerProduct(X, Y) {
-    return matrixFunc(X, Y, distances_js_1.innerProduct);
+function innerProduct$1(X, Y) {
+	return matrixFunc(X, Y, require_distances.innerProduct);
 }
 function euclideanDistance(X, Y) {
-    return matrixFunc(X, Y, euclidean_js_1.euclidean);
+	return matrixFunc(X, Y, require_euclidean.euclidean);
 }
 /**
- * This function implements the Maximal Marginal Relevance algorithm
- * to select a set of embeddings that maximizes the diversity and relevance to a query embedding.
- *
- * @param {number[]|number[][]} queryEmbedding - The query embedding.
- * @param {number[][]} embeddingList - The list of embeddings to select from.
- * @param {number} [lambda=0.5] - The trade-off parameter between relevance and diversity.
- * @param {number} [k=4] - The maximum number of embeddings to select.
- *
- * @returns {number[]} The indexes of the selected embeddings in the embeddingList.
- */
-function maximalMarginalRelevance(queryEmbedding, embeddingList, lambda = 0.5, k = 4) {
-    if (Math.min(k, embeddingList.length) <= 0) {
-        return [];
-    }
-    const queryEmbeddingExpanded = (Array.isArray(queryEmbedding[0]) ? queryEmbedding : [queryEmbedding]);
-    const similarityToQuery = cosineSimilarity(queryEmbeddingExpanded, embeddingList)[0];
-    const mostSimilarEmbeddingIndex = argMax(similarityToQuery).maxIndex;
-    const selectedEmbeddings = [embeddingList[mostSimilarEmbeddingIndex]];
-    const selectedEmbeddingsIndexes = [mostSimilarEmbeddingIndex];
-    while (selectedEmbeddingsIndexes.length < Math.min(k, embeddingList.length)) {
-        let bestScore = -Infinity;
-        let bestIndex = -1;
-        const similarityToSelected = cosineSimilarity(embeddingList, selectedEmbeddings);
-        similarityToQuery.forEach((queryScore, queryScoreIndex) => {
-            if (selectedEmbeddingsIndexes.includes(queryScoreIndex)) {
-                return;
-            }
-            const maxSimilarityToSelected = Math.max(...similarityToSelected[queryScoreIndex]);
-            const score = lambda * queryScore - (1 - lambda) * maxSimilarityToSelected;
-            if (score > bestScore) {
-                bestScore = score;
-                bestIndex = queryScoreIndex;
-            }
-        });
-        selectedEmbeddings.push(embeddingList[bestIndex]);
-        selectedEmbeddingsIndexes.push(bestIndex);
-    }
-    return selectedEmbeddingsIndexes;
+* This function implements the Maximal Marginal Relevance algorithm
+* to select a set of embeddings that maximizes the diversity and relevance to a query embedding.
+*
+* @param {number[]|number[][]} queryEmbedding - The query embedding.
+* @param {number[][]} embeddingList - The list of embeddings to select from.
+* @param {number} [lambda=0.5] - The trade-off parameter between relevance and diversity.
+* @param {number} [k=4] - The maximum number of embeddings to select.
+*
+* @returns {number[]} The indexes of the selected embeddings in the embeddingList.
+*/
+function maximalMarginalRelevance(queryEmbedding, embeddingList, lambda = .5, k = 4) {
+	if (Math.min(k, embeddingList.length) <= 0) return [];
+	const queryEmbeddingExpanded = Array.isArray(queryEmbedding[0]) ? queryEmbedding : [queryEmbedding];
+	const similarityToQuery = cosineSimilarity(queryEmbeddingExpanded, embeddingList)[0];
+	const mostSimilarEmbeddingIndex = argMax(similarityToQuery).maxIndex;
+	const selectedEmbeddings = [embeddingList[mostSimilarEmbeddingIndex]];
+	const selectedEmbeddingsIndexes = [mostSimilarEmbeddingIndex];
+	while (selectedEmbeddingsIndexes.length < Math.min(k, embeddingList.length)) {
+		let bestScore = -Infinity;
+		let bestIndex = -1;
+		const similarityToSelected = cosineSimilarity(embeddingList, selectedEmbeddings);
+		similarityToQuery.forEach((queryScore, queryScoreIndex) => {
+			if (selectedEmbeddingsIndexes.includes(queryScoreIndex)) return;
+			const maxSimilarityToSelected = Math.max(...similarityToSelected[queryScoreIndex]);
+			const score = lambda * queryScore - (1 - lambda) * maxSimilarityToSelected;
+			if (score > bestScore) {
+				bestScore = score;
+				bestIndex = queryScoreIndex;
+			}
+		});
+		selectedEmbeddings.push(embeddingList[bestIndex]);
+		selectedEmbeddingsIndexes.push(bestIndex);
+	}
+	return selectedEmbeddingsIndexes;
 }
 /**
- * Finds the index of the maximum value in the given array.
- * @param {number[]} array - The input array.
- *
- * @returns {number} The index of the maximum value in the array. If the array is empty, returns -1.
- */
+* Finds the index of the maximum value in the given array.
+* @param {number[]} array - The input array.
+*
+* @returns {number} The index of the maximum value in the array. If the array is empty, returns -1.
+*/
 function argMax(array) {
-    if (array.length === 0) {
-        return {
-            maxIndex: -1,
-            maxValue: NaN,
-        };
-    }
-    let maxValue = array[0];
-    let maxIndex = 0;
-    for (let i = 1; i < array.length; i += 1) {
-        if (array[i] > maxValue) {
-            maxIndex = i;
-            maxValue = array[i];
-        }
-    }
-    return { maxIndex, maxValue };
+	if (array.length === 0) return {
+		maxIndex: -1,
+		maxValue: NaN
+	};
+	let maxValue = array[0];
+	let maxIndex = 0;
+	for (let i = 1; i < array.length; i += 1) if (array[i] > maxValue) {
+		maxIndex = i;
+		maxValue = array[i];
+	}
+	return {
+		maxIndex,
+		maxValue
+	};
 }
 function matrixMaxVal(arrays) {
-    return arrays.reduce((acc, array) => Math.max(acc, argMax(array).maxValue), 0);
+	return arrays.reduce((acc, array) => Math.max(acc, argMax(array).maxValue), 0);
 }
+
+//#endregion
+exports.cosineSimilarity = cosineSimilarity;
+exports.euclideanDistance = euclideanDistance;
+exports.innerProduct = innerProduct$1;
+Object.defineProperty(exports, 'math_exports', {
+  enumerable: true,
+  get: function () {
+    return math_exports;
+  }
+});
+exports.matrixFunc = matrixFunc;
+exports.maximalMarginalRelevance = maximalMarginalRelevance;
+exports.normalize = normalize;
+//# sourceMappingURL=math.cjs.map

package/dist/utils/math.cjs.map

@@ -0,0 +1 @@
+{"version":3,"file":"math.cjs","names":["X: number[][]","Y: number[][]","func: VectorFunction","M: number[][]","cosine","innerProduct","innerProductDistance","euclidean","queryEmbedding: number[] | number[][]","embeddingList: number[][]","array: number[]","arrays: number[][]"],"sources":["../../src/utils/math.ts"],"sourcesContent":["import { cosine } from \"./ml-distance/similarities.js\";\nimport { innerProduct as innerProductDistance } from \"./ml-distance/distances.js\";\nimport { euclidean } from \"./ml-distance-euclidean/euclidean.js\";\n\ntype VectorFunction = (xVector: number[], yVector: number[]) => number;\n\n/**\n * Apply a row-wise function between two matrices with the same number of columns.\n *\n * @param {number[][]} X - The first matrix.\n * @param {number[][]} Y - The second matrix.\n * @param {VectorFunction} func - The function to apply.\n *\n * @throws {Error} If the number of columns in X and Y are not the same.\n *\n * @returns {number[][] | [[]]} A matrix where each row represents the result of applying the function between the corresponding rows of X and Y.\n */\n\nexport function matrixFunc(\n  X: number[][],\n  Y: number[][],\n  func: VectorFunction\n): number[][] {\n  if (\n    X.length === 0 ||\n    X[0].length === 0 ||\n    Y.length === 0 ||\n    Y[0].length === 0\n  ) {\n    return [[]];\n  }\n\n  if (X[0].length !== Y[0].length) {\n    throw new Error(\n      `Number of columns in X and Y must be the same. X has shape ${[\n        X.length,\n        X[0].length,\n      ]} and Y has shape ${[Y.length, Y[0].length]}.`\n    );\n  }\n\n  return X.map((xVector) =>\n    Y.map((yVector) => func(xVector, yVector)).map((similarity) =>\n      Number.isNaN(similarity) ? 0 : similarity\n    )\n  );\n}\n\nexport function normalize(M: number[][], similarity = false): number[][] {\n  const max = matrixMaxVal(M);\n  return M.map((row) =>\n    row.map((val) => (similarity ? 1 - val / max : val / max))\n  );\n}\n\n/**\n * This function calculates the row-wise cosine similarity between two matrices with the same number of columns.\n *\n * @param {number[][]} X - The first matrix.\n * @param {number[][]} Y - The second matrix.\n *\n * @throws {Error} If the number of columns in X and Y are not the same.\n *\n * @returns {number[][] | [[]]} A matrix where each row represents the cosine similarity values between the corresponding rows of X and Y.\n */\nexport function cosineSimilarity(X: number[][], Y: number[][]): number[][] {\n  return matrixFunc(X, Y, cosine);\n}\n\nexport function innerProduct(X: number[][], Y: number[][]): number[][] {\n  return matrixFunc(X, Y, innerProductDistance);\n}\n\nexport function euclideanDistance(X: number[][], Y: number[][]): number[][] {\n  return matrixFunc(X, Y, euclidean);\n}\n\n/**\n * This function implements the Maximal Marginal Relevance algorithm\n * to select a set of embeddings that maximizes the diversity and relevance to a query embedding.\n *\n * @param {number[]|number[][]} queryEmbedding - The query embedding.\n * @param {number[][]} embeddingList - The list of embeddings to select from.\n * @param {number} [lambda=0.5] - The trade-off parameter between relevance and diversity.\n * @param {number} [k=4] - The maximum number of embeddings to select.\n *\n * @returns {number[]} The indexes of the selected embeddings in the embeddingList.\n */\nexport function maximalMarginalRelevance(\n  queryEmbedding: number[] | number[][],\n  embeddingList: number[][],\n  lambda = 0.5,\n  k = 4\n): number[] {\n  if (Math.min(k, embeddingList.length) <= 0) {\n    return [];\n  }\n\n  const queryEmbeddingExpanded = (\n    Array.isArray(queryEmbedding[0]) ? queryEmbedding : [queryEmbedding]\n  ) as number[][];\n\n  const similarityToQuery = cosineSimilarity(\n    queryEmbeddingExpanded,\n    embeddingList\n  )[0];\n  const mostSimilarEmbeddingIndex = argMax(similarityToQuery).maxIndex;\n\n  const selectedEmbeddings = [embeddingList[mostSimilarEmbeddingIndex]];\n  const selectedEmbeddingsIndexes = [mostSimilarEmbeddingIndex];\n\n  while (selectedEmbeddingsIndexes.length < Math.min(k, embeddingList.length)) {\n    let bestScore = -Infinity;\n    let bestIndex = -1;\n\n    const similarityToSelected = cosineSimilarity(\n      embeddingList,\n      selectedEmbeddings\n    );\n\n    similarityToQuery.forEach((queryScore, queryScoreIndex) => {\n      if (selectedEmbeddingsIndexes.includes(queryScoreIndex)) {\n        return;\n      }\n      const maxSimilarityToSelected = Math.max(\n        ...similarityToSelected[queryScoreIndex]\n      );\n      const score =\n        lambda * queryScore - (1 - lambda) * maxSimilarityToSelected;\n\n      if (score > bestScore) {\n        bestScore = score;\n        bestIndex = queryScoreIndex;\n      }\n    });\n    selectedEmbeddings.push(embeddingList[bestIndex]);\n    selectedEmbeddingsIndexes.push(bestIndex);\n  }\n\n  return selectedEmbeddingsIndexes;\n}\n\ntype MaxInfo = {\n  maxIndex: number;\n  maxValue: number;\n};\n\n/**\n * Finds the index of the maximum value in the given array.\n * @param {number[]} array - The input array.\n *\n * @returns {number} The index of the maximum value in the array. If the array is empty, returns -1.\n */\nfunction argMax(array: number[]): MaxInfo {\n  if (array.length === 0) {\n    return {\n      maxIndex: -1,\n      maxValue: NaN,\n    };\n  }\n\n  let maxValue = array[0];\n  let maxIndex = 0;\n\n  for (let i = 1; i < array.length; i += 1) {\n    if (array[i] > maxValue) {\n      maxIndex = i;\n      maxValue = array[i];\n    }\n  }\n  return { maxIndex, maxValue };\n}\n\nfunction matrixMaxVal(arrays: number[][]): number {\n  return arrays.reduce(\n    (acc, array) => Math.max(acc, argMax(array).maxValue),\n    0\n  );\n}\n"],"mappings":";;;;;;;;;;;;;;;;;;;;;;;;;;AAkBA,SAAgB,WACdA,GACAC,GACAC,MACY;AACZ,KACE,EAAE,WAAW,KACb,EAAE,GAAG,WAAW,KAChB,EAAE,WAAW,KACb,EAAE,GAAG,WAAW,EAEhB,QAAO,CAAC,CAAE,CAAC;AAGb,KAAI,EAAE,GAAG,WAAW,EAAE,GAAG,OACvB,OAAM,IAAI,MACR,CAAC,2DAA2D,EAAE,CAC5D,EAAE,QACF,EAAE,GAAG,MACN,EAAC,iBAAiB,EAAE,CAAC,EAAE,QAAQ,EAAE,GAAG,MAAO,EAAC,CAAC,CAAC;AAInD,QAAO,EAAE,IAAI,CAAC,YACZ,EAAE,IAAI,CAAC,YAAY,KAAK,SAAS,QAAQ,CAAC,CAAC,IAAI,CAAC,eAC9C,OAAO,MAAM,WAAW,GAAG,IAAI,WAChC,CACF;AACF;AAED,SAAgB,UAAUC,GAAe,aAAa,OAAmB;CACvE,MAAM,MAAM,aAAa,EAAE;AAC3B,QAAO,EAAE,IAAI,CAAC,QACZ,IAAI,IAAI,CAAC,QAAS,aAAa,IAAI,MAAM,MAAM,MAAM,IAAK,CAC3D;AACF;;;;;;;;;;;AAYD,SAAgB,iBAAiBH,GAAeC,GAA2B;AACzE,QAAO,WAAW,GAAG,GAAGG,4BAAO;AAChC;AAED,SAAgBC,eAAaL,GAAeC,GAA2B;AACrE,QAAO,WAAW,GAAG,GAAGK,+BAAqB;AAC9C;AAED,SAAgB,kBAAkBN,GAAeC,GAA2B;AAC1E,QAAO,WAAW,GAAG,GAAGM,4BAAU;AACnC;;;;;;;;;;;;AAaD,SAAgB,yBACdC,gBACAC,eACA,SAAS,IACT,IAAI,GACM;AACV,KAAI,KAAK,IAAI,GAAG,cAAc,OAAO,IAAI,EACvC,QAAO,CAAE;CAGX,MAAM,yBACJ,MAAM,QAAQ,eAAe,GAAG,GAAG,iBAAiB,CAAC,cAAe;CAGtE,MAAM,oBAAoB,iBACxB,wBACA,cACD,CAAC;CACF,MAAM,4BAA4B,OAAO,kBAAkB,CAAC;CAE5D,MAAM,qBAAqB,CAAC,cAAc,0BAA2B;CACrE,MAAM,4BAA4B,CAAC,yBAA0B;AAE7D,QAAO,0BAA0B,SAAS,KAAK,IAAI,GAAG,cAAc,OAAO,EAAE;EAC3E,IAAI,YAAY;EAChB,IAAI,YAAY;EAEhB,MAAM,uBAAuB,iBAC3B,eACA,mBACD;EAED,kBAAkB,QAAQ,CAAC,YAAY,oBAAoB;AACzD,OAAI,0BAA0B,SAAS,gBAAgB,CACrD;GAEF,MAAM,0BAA0B,KAAK,IACnC,GAAG,qBAAqB,iBACzB;GACD,MAAM,QACJ,SAAS,cAAc,IAAI,UAAU;AAEvC,OAAI,QAAQ,WAAW;IACrB,YAAY;IACZ,YAAY;GACb;EACF,EAAC;EACF,mBAAmB,KAAK,cAAc,WAAW;EACjD,0BAA0B,KAAK,UAAU;CAC1C;AAED,QAAO;AACR;;;;;;;AAaD,SAAS,OAAOC,OAA0B;AACxC,KAAI,MAAM,WAAW,EACnB,QAAO;EACL,UAAU;EACV,UAAU;CACX;CAGH,IAAI,WAAW,MAAM;CACrB,IAAI,WAAW;AAEf,MAAK,IAAI,IAAI,GAAG,IAAI,MAAM,QAAQ,KAAK,EACrC,KAAI,MAAM,KAAK,UAAU;EACvB,WAAW;EACX,WAAW,MAAM;CAClB;AAEH,QAAO;EAAE;EAAU;CAAU;AAC9B;AAED,SAAS,aAAaC,QAA4B;AAChD,QAAO,OAAO,OACZ,CAAC,KAAK,UAAU,KAAK,IAAI,KAAK,OAAO,MAAM,CAAC,SAAS,EACrD,EACD;AACF"}

package/dist/utils/math.d.cts

@@ -0,0 +1,43 @@
+//#region src/utils/math.d.ts
+type VectorFunction = (xVector: number[], yVector: number[]) => number;
+/**
+ * Apply a row-wise function between two matrices with the same number of columns.
+ *
+ * @param {number[][]} X - The first matrix.
+ * @param {number[][]} Y - The second matrix.
+ * @param {VectorFunction} func - The function to apply.
+ *
+ * @throws {Error} If the number of columns in X and Y are not the same.
+ *
+ * @returns {number[][] | [[]]} A matrix where each row represents the result of applying the function between the corresponding rows of X and Y.
+ */
+declare function matrixFunc(X: number[][], Y: number[][], func: VectorFunction): number[][];
+declare function normalize(M: number[][], similarity?: boolean): number[][];
+/**
+ * This function calculates the row-wise cosine similarity between two matrices with the same number of columns.
+ *
+ * @param {number[][]} X - The first matrix.
+ * @param {number[][]} Y - The second matrix.
+ *
+ * @throws {Error} If the number of columns in X and Y are not the same.
+ *
+ * @returns {number[][] | [[]]} A matrix where each row represents the cosine similarity values between the corresponding rows of X and Y.
+ */
+declare function cosineSimilarity(X: number[][], Y: number[][]): number[][];
+declare function innerProduct(X: number[][], Y: number[][]): number[][];
+declare function euclideanDistance(X: number[][], Y: number[][]): number[][];
+/**
+ * This function implements the Maximal Marginal Relevance algorithm
+ * to select a set of embeddings that maximizes the diversity and relevance to a query embedding.
+ *
+ * @param {number[]|number[][]} queryEmbedding - The query embedding.
+ * @param {number[][]} embeddingList - The list of embeddings to select from.
+ * @param {number} [lambda=0.5] - The trade-off parameter between relevance and diversity.
+ * @param {number} [k=4] - The maximum number of embeddings to select.
+ *
+ * @returns {number[]} The indexes of the selected embeddings in the embeddingList.
+ */
+declare function maximalMarginalRelevance(queryEmbedding: number[] | number[][], embeddingList: number[][], lambda?: number, k?: number): number[];
+//#endregion
+export { cosineSimilarity, euclideanDistance, innerProduct, matrixFunc, maximalMarginalRelevance, normalize };
+//# sourceMappingURL=math.d.cts.map

package/dist/utils/math.d.cts.map

@@ -0,0 +1 @@
+{"version":3,"file":"math.d.cts","names":["VectorFunction","matrixFunc","normalize","cosineSimilarity","innerProduct","euclideanDistance","maximalMarginalRelevance"],"sources":["../../src/utils/math.d.ts"],"sourcesContent":["type VectorFunction = (xVector: number[], yVector: number[]) => number;\n/**\n * Apply a row-wise function between two matrices with the same number of columns.\n *\n * @param {number[][]} X - The first matrix.\n * @param {number[][]} Y - The second matrix.\n * @param {VectorFunction} func - The function to apply.\n *\n * @throws {Error} If the number of columns in X and Y are not the same.\n *\n * @returns {number[][] | [[]]} A matrix where each row represents the result of applying the function between the corresponding rows of X and Y.\n */\nexport declare function matrixFunc(X: number[][], Y: number[][], func: VectorFunction): number[][];\nexport declare function normalize(M: number[][], similarity?: boolean): number[][];\n/**\n * This function calculates the row-wise cosine similarity between two matrices with the same number of columns.\n *\n * @param {number[][]} X - The first matrix.\n * @param {number[][]} Y - The second matrix.\n *\n * @throws {Error} If the number of columns in X and Y are not the same.\n *\n * @returns {number[][] | [[]]} A matrix where each row represents the cosine similarity values between the corresponding rows of X and Y.\n */\nexport declare function cosineSimilarity(X: number[][], Y: number[][]): number[][];\nexport declare function innerProduct(X: number[][], Y: number[][]): number[][];\nexport declare function euclideanDistance(X: number[][], Y: number[][]): number[][];\n/**\n * This function implements the Maximal Marginal Relevance algorithm\n * to select a set of embeddings that maximizes the diversity and relevance to a query embedding.\n *\n * @param {number[]|number[][]} queryEmbedding - The query embedding.\n * @param {number[][]} embeddingList - The list of embeddings to select from.\n * @param {number} [lambda=0.5] - The trade-off parameter between relevance and diversity.\n * @param {number} [k=4] - The maximum number of embeddings to select.\n *\n * @returns {number[]} The indexes of the selected embeddings in the embeddingList.\n */\nexport declare function maximalMarginalRelevance(queryEmbedding: number[] | number[][], embeddingList: number[][], lambda?: number, k?: number): number[];\nexport {};\n"],"mappings":";KAAKA,cAAAA;;AAYL;AACA;AAWA;AACA;AACA;AAYA;;;;;iBA1BwBC,UAAAA,qCAA+CD;iBAC/CE,SAAAA;;;;;;;;;;;iBAWAC,gBAAAA;iBACAC,YAAAA;iBACAC,iBAAAA;;;;;;;;;;;;iBAYAC,wBAAAA"}

package/dist/utils/math.d.ts

@@ -1,3 +1,4 @@
+//#region src/utils/math.d.ts
 type VectorFunction = (xVector: number[], yVector: number[]) => number;
 /**
  * Apply a row-wise function between two matrices with the same number of columns.
@@ -10,8 +11,8 @@ type VectorFunction = (xVector: number[], yVector: number[]) => number;
  *
  * @returns {number[][] | [[]]} A matrix where each row represents the result of applying the function between the corresponding rows of X and Y.
  */
-export declare function matrixFunc(X: number[][], Y: number[][], func: VectorFunction): number[][];
-export declare function normalize(M: number[][], similarity?: boolean): number[][];
+declare function matrixFunc(X: number[][], Y: number[][], func: VectorFunction): number[][];
+declare function normalize(M: number[][], similarity?: boolean): number[][];
 /**
  * This function calculates the row-wise cosine similarity between two matrices with the same number of columns.
  *
@@ -22,9 +23,9 @@ export declare function normalize(M: number[][], similarity?: boolean): number[]
  *
  * @returns {number[][] | [[]]} A matrix where each row represents the cosine similarity values between the corresponding rows of X and Y.
  */
-export declare function cosineSimilarity(X: number[][], Y: number[][]): number[][];
-export declare function innerProduct(X: number[][], Y: number[][]): number[][];
-export declare function euclideanDistance(X: number[][], Y: number[][]): number[][];
+declare function cosineSimilarity(X: number[][], Y: number[][]): number[][];
+declare function innerProduct(X: number[][], Y: number[][]): number[][];
+declare function euclideanDistance(X: number[][], Y: number[][]): number[][];
 /**
  * This function implements the Maximal Marginal Relevance algorithm
  * to select a set of embeddings that maximizes the diversity and relevance to a query embedding.
@@ -36,5 +37,7 @@ export declare function euclideanDistance(X: number[][], Y: number[][]): number[
  *
  * @returns {number[]} The indexes of the selected embeddings in the embeddingList.
  */
-export declare function maximalMarginalRelevance(queryEmbedding: number[] | number[][], embeddingList: number[][], lambda?: number, k?: number): number[];
-export {};
+declare function maximalMarginalRelevance(queryEmbedding: number[] | number[][], embeddingList: number[][], lambda?: number, k?: number): number[];
+//#endregion
+export { cosineSimilarity, euclideanDistance, innerProduct, matrixFunc, maximalMarginalRelevance, normalize };
+//# sourceMappingURL=math.d.ts.map

package/dist/utils/math.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"math.d.ts","names":["VectorFunction","matrixFunc","normalize","cosineSimilarity","innerProduct","euclideanDistance","maximalMarginalRelevance"],"sources":["../../src/utils/math.d.ts"],"sourcesContent":["type VectorFunction = (xVector: number[], yVector: number[]) => number;\n/**\n * Apply a row-wise function between two matrices with the same number of columns.\n *\n * @param {number[][]} X - The first matrix.\n * @param {number[][]} Y - The second matrix.\n * @param {VectorFunction} func - The function to apply.\n *\n * @throws {Error} If the number of columns in X and Y are not the same.\n *\n * @returns {number[][] | [[]]} A matrix where each row represents the result of applying the function between the corresponding rows of X and Y.\n */\nexport declare function matrixFunc(X: number[][], Y: number[][], func: VectorFunction): number[][];\nexport declare function normalize(M: number[][], similarity?: boolean): number[][];\n/**\n * This function calculates the row-wise cosine similarity between two matrices with the same number of columns.\n *\n * @param {number[][]} X - The first matrix.\n * @param {number[][]} Y - The second matrix.\n *\n * @throws {Error} If the number of columns in X and Y are not the same.\n *\n * @returns {number[][] | [[]]} A matrix where each row represents the cosine similarity values between the corresponding rows of X and Y.\n */\nexport declare function cosineSimilarity(X: number[][], Y: number[][]): number[][];\nexport declare function innerProduct(X: number[][], Y: number[][]): number[][];\nexport declare function euclideanDistance(X: number[][], Y: number[][]): number[][];\n/**\n * This function implements the Maximal Marginal Relevance algorithm\n * to select a set of embeddings that maximizes the diversity and relevance to a query embedding.\n *\n * @param {number[]|number[][]} queryEmbedding - The query embedding.\n * @param {number[][]} embeddingList - The list of embeddings to select from.\n * @param {number} [lambda=0.5] - The trade-off parameter between relevance and diversity.\n * @param {number} [k=4] - The maximum number of embeddings to select.\n *\n * @returns {number[]} The indexes of the selected embeddings in the embeddingList.\n */\nexport declare function maximalMarginalRelevance(queryEmbedding: number[] | number[][], embeddingList: number[][], lambda?: number, k?: number): number[];\nexport {};\n"],"mappings":";KAAKA,cAAAA;;AAYL;AACA;AAWA;AACA;AACA;AAYA;;;;;iBA1BwBC,UAAAA,qCAA+CD;iBAC/CE,SAAAA;;;;;;;;;;;iBAWAC,gBAAAA;iBACAC,YAAAA;iBACAC,iBAAAA;;;;;;;;;;;;iBAYAC,wBAAAA"}

package/dist/utils/math.js

@@ -1,118 +1,119 @@
+import { __export } from "../_virtual/rolldown_runtime.js";
 import { cosine } from "./ml-distance/similarities.js";
-import { innerProduct as innerProductDistance } from "./ml-distance/distances.js";
+import { innerProduct } from "./ml-distance/distances.js";
 import { euclidean } from "./ml-distance-euclidean/euclidean.js";
+
+//#region src/utils/math.ts
+var math_exports = {};
+__export(math_exports, {
+	cosineSimilarity: () => cosineSimilarity,
+	euclideanDistance: () => euclideanDistance,
+	innerProduct: () => innerProduct$1,
+	matrixFunc: () => matrixFunc,
+	maximalMarginalRelevance: () => maximalMarginalRelevance,
+	normalize: () => normalize
+});
 /**
- * Apply a row-wise function between two matrices with the same number of columns.
- *
- * @param {number[][]} X - The first matrix.
- * @param {number[][]} Y - The second matrix.
- * @param {VectorFunction} func - The function to apply.
- *
- * @throws {Error} If the number of columns in X and Y are not the same.
- *
- * @returns {number[][] | [[]]} A matrix where each row represents the result of applying the function between the corresponding rows of X and Y.
- */
-export function matrixFunc(X, Y, func) {
-    if (X.length === 0 ||
-        X[0].length === 0 ||
-        Y.length === 0 ||
-        Y[0].length === 0) {
-        return [[]];
-    }
-    if (X[0].length !== Y[0].length) {
-        throw new Error(`Number of columns in X and Y must be the same. X has shape ${[
-            X.length,
-            X[0].length,
-        ]} and Y has shape ${[Y.length, Y[0].length]}.`);
-    }
-    return X.map((xVector) => Y.map((yVector) => func(xVector, yVector)).map((similarity) => Number.isNaN(similarity) ? 0 : similarity));
+* Apply a row-wise function between two matrices with the same number of columns.
+*
+* @param {number[][]} X - The first matrix.
+* @param {number[][]} Y - The second matrix.
+* @param {VectorFunction} func - The function to apply.
+*
+* @throws {Error} If the number of columns in X and Y are not the same.
+*
+* @returns {number[][] | [[]]} A matrix where each row represents the result of applying the function between the corresponding rows of X and Y.
+*/
+function matrixFunc(X, Y, func) {
+	if (X.length === 0 || X[0].length === 0 || Y.length === 0 || Y[0].length === 0) return [[]];
+	if (X[0].length !== Y[0].length) throw new Error(`Number of columns in X and Y must be the same. X has shape ${[X.length, X[0].length]} and Y has shape ${[Y.length, Y[0].length]}.`);
+	return X.map((xVector) => Y.map((yVector) => func(xVector, yVector)).map((similarity) => Number.isNaN(similarity) ? 0 : similarity));
 }
-export function normalize(M, similarity = false) {
-    const max = matrixMaxVal(M);
-    return M.map((row) => row.map((val) => (similarity ? 1 - val / max : val / max)));
+function normalize(M, similarity = false) {
+	const max = matrixMaxVal(M);
+	return M.map((row) => row.map((val) => similarity ? 1 - val / max : val / max));
 }
 /**
- * This function calculates the row-wise cosine similarity between two matrices with the same number of columns.
- *
- * @param {number[][]} X - The first matrix.
- * @param {number[][]} Y - The second matrix.
- *
- * @throws {Error} If the number of columns in X and Y are not the same.
- *
- * @returns {number[][] | [[]]} A matrix where each row represents the cosine similarity values between the corresponding rows of X and Y.
- */
-export function cosineSimilarity(X, Y) {
-    return matrixFunc(X, Y, cosine);
+* This function calculates the row-wise cosine similarity between two matrices with the same number of columns.
+*
+* @param {number[][]} X - The first matrix.
+* @param {number[][]} Y - The second matrix.
+*
+* @throws {Error} If the number of columns in X and Y are not the same.
+*
+* @returns {number[][] | [[]]} A matrix where each row represents the cosine similarity values between the corresponding rows of X and Y.
+*/
+function cosineSimilarity(X, Y) {
+	return matrixFunc(X, Y, cosine);
 }
-export function innerProduct(X, Y) {
-    return matrixFunc(X, Y, innerProductDistance);
+function innerProduct$1(X, Y) {
+	return matrixFunc(X, Y, innerProduct);
 }
-export function euclideanDistance(X, Y) {
-    return matrixFunc(X, Y, euclidean);
+function euclideanDistance(X, Y) {
+	return matrixFunc(X, Y, euclidean);
 }
 /**
- * This function implements the Maximal Marginal Relevance algorithm
- * to select a set of embeddings that maximizes the diversity and relevance to a query embedding.
- *
- * @param {number[]|number[][]} queryEmbedding - The query embedding.
- * @param {number[][]} embeddingList - The list of embeddings to select from.
- * @param {number} [lambda=0.5] - The trade-off parameter between relevance and diversity.
- * @param {number} [k=4] - The maximum number of embeddings to select.
- *
- * @returns {number[]} The indexes of the selected embeddings in the embeddingList.
- */
-export function maximalMarginalRelevance(queryEmbedding, embeddingList, lambda = 0.5, k = 4) {
-    if (Math.min(k, embeddingList.length) <= 0) {
-        return [];
-    }
-    const queryEmbeddingExpanded = (Array.isArray(queryEmbedding[0]) ? queryEmbedding : [queryEmbedding]);
-    const similarityToQuery = cosineSimilarity(queryEmbeddingExpanded, embeddingList)[0];
-    const mostSimilarEmbeddingIndex = argMax(similarityToQuery).maxIndex;
-    const selectedEmbeddings = [embeddingList[mostSimilarEmbeddingIndex]];
-    const selectedEmbeddingsIndexes = [mostSimilarEmbeddingIndex];
-    while (selectedEmbeddingsIndexes.length < Math.min(k, embeddingList.length)) {
-        let bestScore = -Infinity;
-        let bestIndex = -1;
-        const similarityToSelected = cosineSimilarity(embeddingList, selectedEmbeddings);
-        similarityToQuery.forEach((queryScore, queryScoreIndex) => {
-            if (selectedEmbeddingsIndexes.includes(queryScoreIndex)) {
-                return;
-            }
-            const maxSimilarityToSelected = Math.max(...similarityToSelected[queryScoreIndex]);
-            const score = lambda * queryScore - (1 - lambda) * maxSimilarityToSelected;
-            if (score > bestScore) {
-                bestScore = score;
-                bestIndex = queryScoreIndex;
-            }
-        });
-        selectedEmbeddings.push(embeddingList[bestIndex]);
-        selectedEmbeddingsIndexes.push(bestIndex);
-    }
-    return selectedEmbeddingsIndexes;
+* This function implements the Maximal Marginal Relevance algorithm
+* to select a set of embeddings that maximizes the diversity and relevance to a query embedding.
+*
+* @param {number[]|number[][]} queryEmbedding - The query embedding.
+* @param {number[][]} embeddingList - The list of embeddings to select from.
+* @param {number} [lambda=0.5] - The trade-off parameter between relevance and diversity.
+* @param {number} [k=4] - The maximum number of embeddings to select.
+*
+* @returns {number[]} The indexes of the selected embeddings in the embeddingList.
+*/
+function maximalMarginalRelevance(queryEmbedding, embeddingList, lambda = .5, k = 4) {
+	if (Math.min(k, embeddingList.length) <= 0) return [];
+	const queryEmbeddingExpanded = Array.isArray(queryEmbedding[0]) ? queryEmbedding : [queryEmbedding];
+	const similarityToQuery = cosineSimilarity(queryEmbeddingExpanded, embeddingList)[0];
+	const mostSimilarEmbeddingIndex = argMax(similarityToQuery).maxIndex;
+	const selectedEmbeddings = [embeddingList[mostSimilarEmbeddingIndex]];
+	const selectedEmbeddingsIndexes = [mostSimilarEmbeddingIndex];
+	while (selectedEmbeddingsIndexes.length < Math.min(k, embeddingList.length)) {
+		let bestScore = -Infinity;
+		let bestIndex = -1;
+		const similarityToSelected = cosineSimilarity(embeddingList, selectedEmbeddings);
+		similarityToQuery.forEach((queryScore, queryScoreIndex) => {
+			if (selectedEmbeddingsIndexes.includes(queryScoreIndex)) return;
+			const maxSimilarityToSelected = Math.max(...similarityToSelected[queryScoreIndex]);
+			const score = lambda * queryScore - (1 - lambda) * maxSimilarityToSelected;
+			if (score > bestScore) {
+				bestScore = score;
+				bestIndex = queryScoreIndex;
+			}
+		});
+		selectedEmbeddings.push(embeddingList[bestIndex]);
+		selectedEmbeddingsIndexes.push(bestIndex);
+	}
+	return selectedEmbeddingsIndexes;
 }
 /**
- * Finds the index of the maximum value in the given array.
- * @param {number[]} array - The input array.
- *
- * @returns {number} The index of the maximum value in the array. If the array is empty, returns -1.
- */
+* Finds the index of the maximum value in the given array.
+* @param {number[]} array - The input array.
+*
+* @returns {number} The index of the maximum value in the array. If the array is empty, returns -1.
+*/
 function argMax(array) {
-    if (array.length === 0) {
-        return {
-            maxIndex: -1,
-            maxValue: NaN,
-        };
-    }
-    let maxValue = array[0];
-    let maxIndex = 0;
-    for (let i = 1; i < array.length; i += 1) {
-        if (array[i] > maxValue) {
-            maxIndex = i;
-            maxValue = array[i];
-        }
-    }
-    return { maxIndex, maxValue };
+	if (array.length === 0) return {
+		maxIndex: -1,
+		maxValue: NaN
+	};
+	let maxValue = array[0];
+	let maxIndex = 0;
+	for (let i = 1; i < array.length; i += 1) if (array[i] > maxValue) {
+		maxIndex = i;
+		maxValue = array[i];
+	}
+	return {
+		maxIndex,
+		maxValue
+	};
 }
 function matrixMaxVal(arrays) {
-    return arrays.reduce((acc, array) => Math.max(acc, argMax(array).maxValue), 0);
+	return arrays.reduce((acc, array) => Math.max(acc, argMax(array).maxValue), 0);
 }
+
+//#endregion
+export { cosineSimilarity, euclideanDistance, innerProduct$1 as innerProduct, math_exports, matrixFunc, maximalMarginalRelevance, normalize };
+//# sourceMappingURL=math.js.map

package/dist/utils/math.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"math.js","names":["X: number[][]","Y: number[][]","func: VectorFunction","M: number[][]","innerProduct","innerProductDistance","queryEmbedding: number[] | number[][]","embeddingList: number[][]","array: number[]","arrays: number[][]"],"sources":["../../src/utils/math.ts"],"sourcesContent":["import { cosine } from \"./ml-distance/similarities.js\";\nimport { innerProduct as innerProductDistance } from \"./ml-distance/distances.js\";\nimport { euclidean } from \"./ml-distance-euclidean/euclidean.js\";\n\ntype VectorFunction = (xVector: number[], yVector: number[]) => number;\n\n/**\n * Apply a row-wise function between two matrices with the same number of columns.\n *\n * @param {number[][]} X - The first matrix.\n * @param {number[][]} Y - The second matrix.\n * @param {VectorFunction} func - The function to apply.\n *\n * @throws {Error} If the number of columns in X and Y are not the same.\n *\n * @returns {number[][] | [[]]} A matrix where each row represents the result of applying the function between the corresponding rows of X and Y.\n */\n\nexport function matrixFunc(\n  X: number[][],\n  Y: number[][],\n  func: VectorFunction\n): number[][] {\n  if (\n    X.length === 0 ||\n    X[0].length === 0 ||\n    Y.length === 0 ||\n    Y[0].length === 0\n  ) {\n    return [[]];\n  }\n\n  if (X[0].length !== Y[0].length) {\n    throw new Error(\n      `Number of columns in X and Y must be the same. X has shape ${[\n        X.length,\n        X[0].length,\n      ]} and Y has shape ${[Y.length, Y[0].length]}.`\n    );\n  }\n\n  return X.map((xVector) =>\n    Y.map((yVector) => func(xVector, yVector)).map((similarity) =>\n      Number.isNaN(similarity) ? 0 : similarity\n    )\n  );\n}\n\nexport function normalize(M: number[][], similarity = false): number[][] {\n  const max = matrixMaxVal(M);\n  return M.map((row) =>\n    row.map((val) => (similarity ? 1 - val / max : val / max))\n  );\n}\n\n/**\n * This function calculates the row-wise cosine similarity between two matrices with the same number of columns.\n *\n * @param {number[][]} X - The first matrix.\n * @param {number[][]} Y - The second matrix.\n *\n * @throws {Error} If the number of columns in X and Y are not the same.\n *\n * @returns {number[][] | [[]]} A matrix where each row represents the cosine similarity values between the corresponding rows of X and Y.\n */\nexport function cosineSimilarity(X: number[][], Y: number[][]): number[][] {\n  return matrixFunc(X, Y, cosine);\n}\n\nexport function innerProduct(X: number[][], Y: number[][]): number[][] {\n  return matrixFunc(X, Y, innerProductDistance);\n}\n\nexport function euclideanDistance(X: number[][], Y: number[][]): number[][] {\n  return matrixFunc(X, Y, euclidean);\n}\n\n/**\n * This function implements the Maximal Marginal Relevance algorithm\n * to select a set of embeddings that maximizes the diversity and relevance to a query embedding.\n *\n * @param {number[]|number[][]} queryEmbedding - The query embedding.\n * @param {number[][]} embeddingList - The list of embeddings to select from.\n * @param {number} [lambda=0.5] - The trade-off parameter between relevance and diversity.\n * @param {number} [k=4] - The maximum number of embeddings to select.\n *\n * @returns {number[]} The indexes of the selected embeddings in the embeddingList.\n */\nexport function maximalMarginalRelevance(\n  queryEmbedding: number[] | number[][],\n  embeddingList: number[][],\n  lambda = 0.5,\n  k = 4\n): number[] {\n  if (Math.min(k, embeddingList.length) <= 0) {\n    return [];\n  }\n\n  const queryEmbeddingExpanded = (\n    Array.isArray(queryEmbedding[0]) ? queryEmbedding : [queryEmbedding]\n  ) as number[][];\n\n  const similarityToQuery = cosineSimilarity(\n    queryEmbeddingExpanded,\n    embeddingList\n  )[0];\n  const mostSimilarEmbeddingIndex = argMax(similarityToQuery).maxIndex;\n\n  const selectedEmbeddings = [embeddingList[mostSimilarEmbeddingIndex]];\n  const selectedEmbeddingsIndexes = [mostSimilarEmbeddingIndex];\n\n  while (selectedEmbeddingsIndexes.length < Math.min(k, embeddingList.length)) {\n    let bestScore = -Infinity;\n    let bestIndex = -1;\n\n    const similarityToSelected = cosineSimilarity(\n      embeddingList,\n      selectedEmbeddings\n    );\n\n    similarityToQuery.forEach((queryScore, queryScoreIndex) => {\n      if (selectedEmbeddingsIndexes.includes(queryScoreIndex)) {\n        return;\n      }\n      const maxSimilarityToSelected = Math.max(\n        ...similarityToSelected[queryScoreIndex]\n      );\n      const score =\n        lambda * queryScore - (1 - lambda) * maxSimilarityToSelected;\n\n      if (score > bestScore) {\n        bestScore = score;\n        bestIndex = queryScoreIndex;\n      }\n    });\n    selectedEmbeddings.push(embeddingList[bestIndex]);\n    selectedEmbeddingsIndexes.push(bestIndex);\n  }\n\n  return selectedEmbeddingsIndexes;\n}\n\ntype MaxInfo = {\n  maxIndex: number;\n  maxValue: number;\n};\n\n/**\n * Finds the index of the maximum value in the given array.\n * @param {number[]} array - The input array.\n *\n * @returns {number} The index of the maximum value in the array. If the array is empty, returns -1.\n */\nfunction argMax(array: number[]): MaxInfo {\n  if (array.length === 0) {\n    return {\n      maxIndex: -1,\n      maxValue: NaN,\n    };\n  }\n\n  let maxValue = array[0];\n  let maxIndex = 0;\n\n  for (let i = 1; i < array.length; i += 1) {\n    if (array[i] > maxValue) {\n      maxIndex = i;\n      maxValue = array[i];\n    }\n  }\n  return { maxIndex, maxValue };\n}\n\nfunction matrixMaxVal(arrays: number[][]): number {\n  return arrays.reduce(\n    (acc, array) => Math.max(acc, argMax(array).maxValue),\n    0\n  );\n}\n"],"mappings":";;;;;;;;;;;;;;;;;;;;;;;;;;AAkBA,SAAgB,WACdA,GACAC,GACAC,MACY;AACZ,KACE,EAAE,WAAW,KACb,EAAE,GAAG,WAAW,KAChB,EAAE,WAAW,KACb,EAAE,GAAG,WAAW,EAEhB,QAAO,CAAC,CAAE,CAAC;AAGb,KAAI,EAAE,GAAG,WAAW,EAAE,GAAG,OACvB,OAAM,IAAI,MACR,CAAC,2DAA2D,EAAE,CAC5D,EAAE,QACF,EAAE,GAAG,MACN,EAAC,iBAAiB,EAAE,CAAC,EAAE,QAAQ,EAAE,GAAG,MAAO,EAAC,CAAC,CAAC;AAInD,QAAO,EAAE,IAAI,CAAC,YACZ,EAAE,IAAI,CAAC,YAAY,KAAK,SAAS,QAAQ,CAAC,CAAC,IAAI,CAAC,eAC9C,OAAO,MAAM,WAAW,GAAG,IAAI,WAChC,CACF;AACF;AAED,SAAgB,UAAUC,GAAe,aAAa,OAAmB;CACvE,MAAM,MAAM,aAAa,EAAE;AAC3B,QAAO,EAAE,IAAI,CAAC,QACZ,IAAI,IAAI,CAAC,QAAS,aAAa,IAAI,MAAM,MAAM,MAAM,IAAK,CAC3D;AACF;;;;;;;;;;;AAYD,SAAgB,iBAAiBH,GAAeC,GAA2B;AACzE,QAAO,WAAW,GAAG,GAAG,OAAO;AAChC;AAED,SAAgBG,eAAaJ,GAAeC,GAA2B;AACrE,QAAO,WAAW,GAAG,GAAGI,aAAqB;AAC9C;AAED,SAAgB,kBAAkBL,GAAeC,GAA2B;AAC1E,QAAO,WAAW,GAAG,GAAG,UAAU;AACnC;;;;;;;;;;;;AAaD,SAAgB,yBACdK,gBACAC,eACA,SAAS,IACT,IAAI,GACM;AACV,KAAI,KAAK,IAAI,GAAG,cAAc,OAAO,IAAI,EACvC,QAAO,CAAE;CAGX,MAAM,yBACJ,MAAM,QAAQ,eAAe,GAAG,GAAG,iBAAiB,CAAC,cAAe;CAGtE,MAAM,oBAAoB,iBACxB,wBACA,cACD,CAAC;CACF,MAAM,4BAA4B,OAAO,kBAAkB,CAAC;CAE5D,MAAM,qBAAqB,CAAC,cAAc,0BAA2B;CACrE,MAAM,4BAA4B,CAAC,yBAA0B;AAE7D,QAAO,0BAA0B,SAAS,KAAK,IAAI,GAAG,cAAc,OAAO,EAAE;EAC3E,IAAI,YAAY;EAChB,IAAI,YAAY;EAEhB,MAAM,uBAAuB,iBAC3B,eACA,mBACD;EAED,kBAAkB,QAAQ,CAAC,YAAY,oBAAoB;AACzD,OAAI,0BAA0B,SAAS,gBAAgB,CACrD;GAEF,MAAM,0BAA0B,KAAK,IACnC,GAAG,qBAAqB,iBACzB;GACD,MAAM,QACJ,SAAS,cAAc,IAAI,UAAU;AAEvC,OAAI,QAAQ,WAAW;IACrB,YAAY;IACZ,YAAY;GACb;EACF,EAAC;EACF,mBAAmB,KAAK,cAAc,WAAW;EACjD,0BAA0B,KAAK,UAAU;CAC1C;AAED,QAAO;AACR;;;;;;;AAaD,SAAS,OAAOC,OAA0B;AACxC,KAAI,MAAM,WAAW,EACnB,QAAO;EACL,UAAU;EACV,UAAU;CACX;CAGH,IAAI,WAAW,MAAM;CACrB,IAAI,WAAW;AAEf,MAAK,IAAI,IAAI,GAAG,IAAI,MAAM,QAAQ,KAAK,EACrC,KAAI,MAAM,KAAK,UAAU;EACvB,WAAW;EACX,WAAW,MAAM;CAClB;AAEH,QAAO;EAAE;EAAU;CAAU;AAC9B;AAED,SAAS,aAAaC,QAA4B;AAChD,QAAO,OAAO,OACZ,CAAC,KAAK,UAAU,KAAK,IAAI,KAAK,OAAO,MAAM,CAAC,SAAS,EACrD,EACD;AACF"}

package/dist/utils/ml-distance/distances.cjs

@@ -1,17 +1,18 @@
-"use strict";
-Object.defineProperty(exports, "__esModule", { value: true });
-exports.innerProduct = innerProduct;
+
+//#region src/utils/ml-distance/distances.ts
 /**
- *Returns the Inner Product similarity between vectors a and b
- * @link [Inner Product Similarity algorithm](https://www.naun.org/main/NAUN/ijmmas/mmmas-49.pdf)
- * @param a - first vector
- * @param b - second vector
- *
- */
+*Returns the Inner Product similarity between vectors a and b
+* @link [Inner Product Similarity algorithm](https://www.naun.org/main/NAUN/ijmmas/mmmas-49.pdf)
+* @param a - first vector
+* @param b - second vector
+*
+*/
 function innerProduct(a, b) {
-    let ans = 0;
-    for (let i = 0; i < a.length; i++) {
-        ans += a[i] * b[i];
-    }
-    return ans;
+	let ans = 0;
+	for (let i = 0; i < a.length; i++) ans += a[i] * b[i];
+	return ans;
 }
+
+//#endregion
+exports.innerProduct = innerProduct;
+//# sourceMappingURL=distances.cjs.map