hyperspace-sdk-ts 3.0.0 → 3.0.1

package/README.md

@@ -39,6 +39,9 @@ async function main() {
   await client.insert(1, [0.1, 0.2, 0.3], { source: "demo" }, collection);
   await client.insert(2, [0.2, 0.1, 0.4], { source: "demo" }, collection);
 
+  // Delete vector by ID
+  await client.delete(1);
+
   const results = await client.search([0.1, 0.2, 0.3], 5, collection);
   console.log(results);
 

package/dist/client.d.ts

@@ -55,6 +55,10 @@ export declare const HyperbolicMath: {
     riemannianGradient(x: number[], euclideanGrad: number[], c?: number): number[];
     parallelTransport(x: number[], y: number[], v: number[], c?: number): number[];
     frechetMean(points: number[][], c?: number, maxIter?: number, tol?: number): number[];
+    analyzeDeltaHyperbolicity(vectors: number[][], numSamples?: number): {
+        delta: number;
+        recommendation: string;
+    };
 };
 export declare class HyperspaceClient {
     private client;
@@ -65,6 +69,7 @@ export declare class HyperspaceClient {
     constructor(host?: string, apiKey?: string, userId?: string);
     createCollection(name: string, dimension: number, metric: string): Promise<boolean>;
     deleteCollection(name: string): Promise<boolean>;
+    delete(id: number, collection?: string): Promise<boolean>;
     insert(id: number, vector: number[] | Float32Array | Float64Array, meta?: {
         [key: string]: string;
     }, collection?: string, durability?: DurabilityLevel, typedMetadata?: {

package/dist/client.js

@@ -152,6 +152,33 @@ exports.HyperbolicMath = {
             mu = exports.HyperbolicMath.projectToBall(mu, c);
         }
         return mu;
+    },
+    analyzeDeltaHyperbolicity(vectors, numSamples = 1000) {
+        if (vectors.length < 4)
+            return { delta: 0, recommendation: 'euclidean' };
+        const l2Dist = (a, b) => Math.sqrt(a.reduce((s, x, i) => s + (x - b[i]) ** 2, 0));
+        let maxDelta = 0;
+        for (let s = 0; s < numSamples; s++) {
+            const indices = new Set();
+            while (indices.size < 4)
+                indices.add(Math.floor(Math.random() * vectors.length));
+            const [i, j, k, l] = Array.from(indices);
+            const d_ij = l2Dist(vectors[i], vectors[j]);
+            const d_kl = l2Dist(vectors[k], vectors[l]);
+            const d_ik = l2Dist(vectors[i], vectors[k]);
+            const d_jl = l2Dist(vectors[j], vectors[l]);
+            const d_il = l2Dist(vectors[i], vectors[l]);
+            const d_jk = l2Dist(vectors[j], vectors[k]);
+            const s1 = d_ij + d_kl;
+            const s2 = d_ik + d_jl;
+            const s3 = d_il + d_jk;
+            const sums = [s1, s2, s3].sort((a, b) => b - a);
+            const delta = (sums[0] - sums[1]) / 2.0;
+            if (delta > maxDelta)
+                maxDelta = delta;
+        }
+        const recommendation = maxDelta < 0.15 ? 'lorentz' : (maxDelta < 0.30 ? 'poincare' : 'l2');
+        return { delta: maxDelta, recommendation };
     }
 };
 class HyperspaceClient {
@@ -241,6 +268,18 @@ class HyperspaceClient {
             });
         });
     }
+    delete(id, collection = '') {
+        return new Promise((resolve, reject) => {
+            const req = new hyperspace_pb.DeleteRequest();
+            req.setCollection(collection);
+            req.setId(id);
+            this.client.delete(req, this.metadata, (err, resp) => {
+                if (err)
+                    return reject(err);
+                resolve(resp.getSuccess());
+            });
+        });
+    }
     insert(id, vector, meta, collection = '', durability = hyperspace_pb_1.DurabilityLevel.DEFAULT_LEVEL, typedMetadata) {
         return new Promise((resolve, reject) => {
             const req = new hyperspace_pb_1.InsertRequest();

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "hyperspace-sdk-ts",
-  "version": "3.0.0",
+  "version": "3.0.1",
   "description": "Official TypeScript SDK for HyperspaceDB gRPC API",
   "main": "dist/client.js",
   "types": "dist/client.d.ts",