@samyok/annoy 1.0.0

package/deps/annoy/src/kissrandom.h

@@ -0,0 +1,120 @@
+#ifndef ANNOY_KISSRANDOM_H
+#define ANNOY_KISSRANDOM_H
+
+#if defined(_MSC_VER) && _MSC_VER == 1500
+typedef unsigned __int32    uint32_t;
+typedef unsigned __int64    uint64_t;
+#else
+#include <stdint.h>
+#endif
+
+namespace Annoy {
+
+// KISS = "keep it simple, stupid", but high quality random number generator
+// http://www0.cs.ucl.ac.uk/staff/d.jones/GoodPracticeRNG.pdf -> "Use a good RNG and build it into your code"
+// http://mathforum.org/kb/message.jspa?messageID=6627731
+// https://de.wikipedia.org/wiki/KISS_(Zufallszahlengenerator)
+
+// 32 bit KISS
+struct Kiss32Random {
+  uint32_t x;
+  uint32_t y;
+  uint32_t z;
+  uint32_t c;
+
+  static const uint32_t default_seed = 123456789;
+#if __cplusplus < 201103L
+  typedef uint32_t seed_type;
+#endif
+
+  // seed must be != 0
+  Kiss32Random(uint32_t seed = default_seed) {
+    x = seed;
+    y = 362436000;
+    z = 521288629;
+    c = 7654321;
+  }
+
+  uint32_t kiss() {
+    // Linear congruence generator
+    x = 69069 * x + 12345;
+
+    // Xor shift
+    y ^= y << 13;
+    y ^= y >> 17;
+    y ^= y << 5;
+
+    // Multiply-with-carry
+    uint64_t t = 698769069ULL * z + c;
+    c = t >> 32;
+    z = (uint32_t) t;
+
+    return x + y + z;
+  }
+  inline int flip() {
+    // Draw random 0 or 1
+    return kiss() & 1;
+  }
+  inline size_t index(size_t n) {
+    // Draw random integer between 0 and n-1 where n is at most the number of data points you have
+    return kiss() % n;
+  }
+  inline void set_seed(uint32_t seed) {
+    x = seed;
+  }
+};
+
+// 64 bit KISS. Use this if you have more than about 2^24 data points ("big data" ;) )
+struct Kiss64Random {
+  uint64_t x;
+  uint64_t y;
+  uint64_t z;
+  uint64_t c;
+
+  static const uint64_t default_seed = 1234567890987654321ULL;
+#if __cplusplus < 201103L
+  typedef uint64_t seed_type;
+#endif
+
+  // seed must be != 0
+  Kiss64Random(uint64_t seed = default_seed) {
+    x = seed;
+    y = 362436362436362436ULL;
+    z = 1066149217761810ULL;
+    c = 123456123456123456ULL;
+  }
+
+  uint64_t kiss() {
+    // Linear congruence generator
+    z = 6906969069LL*z+1234567;
+
+    // Xor shift
+    y ^= (y<<13);
+    y ^= (y>>17);
+    y ^= (y<<43);
+
+    // Multiply-with-carry (uint128_t t = (2^58 + 1) * x + c; c = t >> 64; x = (uint64_t) t)
+    uint64_t t = (x<<58)+c;
+    c = (x>>6);
+    x += t;
+    c += (x<t);
+
+    return x + y + z;
+  }
+  inline int flip() {
+    // Draw random 0 or 1
+    return kiss() & 1;
+  }
+  inline size_t index(size_t n) {
+    // Draw random integer between 0 and n-1 where n is at most the number of data points you have
+    return kiss() % n;
+  }
+  inline void set_seed(uint64_t seed) {
+    x = seed;
+  }
+};
+
+}
+
+#endif
+// vim: tabstop=2 shiftwidth=2

package/deps/annoy/src/mman.h

@@ -0,0 +1,242 @@
+
+// This is from https://code.google.com/p/mman-win32/
+// 
+// Licensed under MIT
+
+#ifndef _MMAN_WIN32_H
+#define _MMAN_WIN32_H
+
+#ifndef _WIN32_WINNT		// Allow use of features specific to Windows XP or later.                   
+#define _WIN32_WINNT 0x0501	// Change this to the appropriate value to target other versions of Windows.
+#endif						
+
+#include <sys/types.h>
+#include <windows.h>
+#include <errno.h>
+#include <io.h>
+
+#define PROT_NONE       0
+#define PROT_READ       1
+#define PROT_WRITE      2
+#define PROT_EXEC       4
+
+#define MAP_FILE        0
+#define MAP_SHARED      1
+#define MAP_PRIVATE     2
+#define MAP_TYPE        0xf
+#define MAP_FIXED       0x10
+#define MAP_ANONYMOUS   0x20
+#define MAP_ANON        MAP_ANONYMOUS
+
+#define MAP_FAILED      ((void *)-1)
+
+/* Flags for msync. */
+#define MS_ASYNC        1
+#define MS_SYNC         2
+#define MS_INVALIDATE   4
+
+#ifndef FILE_MAP_EXECUTE
+#define FILE_MAP_EXECUTE    0x0020
+#endif
+
+static int __map_mman_error(const DWORD err, const int deferr)
+{
+    if (err == 0)
+        return 0;
+    //TODO: implement
+    return err;
+}
+
+static DWORD __map_mmap_prot_page(const int prot)
+{
+    DWORD protect = 0;
+    
+    if (prot == PROT_NONE)
+        return protect;
+        
+    if ((prot & PROT_EXEC) != 0)
+    {
+        protect = ((prot & PROT_WRITE) != 0) ? 
+                    PAGE_EXECUTE_READWRITE : PAGE_EXECUTE_READ;
+    }
+    else
+    {
+        protect = ((prot & PROT_WRITE) != 0) ?
+                    PAGE_READWRITE : PAGE_READONLY;
+    }
+    
+    return protect;
+}
+
+static DWORD __map_mmap_prot_file(const int prot)
+{
+    DWORD desiredAccess = 0;
+    
+    if (prot == PROT_NONE)
+        return desiredAccess;
+        
+    if ((prot & PROT_READ) != 0)
+        desiredAccess |= FILE_MAP_READ;
+    if ((prot & PROT_WRITE) != 0)
+        desiredAccess |= FILE_MAP_WRITE;
+    if ((prot & PROT_EXEC) != 0)
+        desiredAccess |= FILE_MAP_EXECUTE;
+    
+    return desiredAccess;
+}
+
+inline void* mmap(void *addr, size_t len, int prot, int flags, int fildes, off_t off)
+{
+    HANDLE fm, h;
+    
+    void * map = MAP_FAILED;
+    
+#ifdef _MSC_VER
+#pragma warning(push)
+#pragma warning(disable: 4293)
+#endif
+
+    const DWORD dwFileOffsetLow = (sizeof(off_t) <= sizeof(DWORD)) ? 
+                    (DWORD)off : (DWORD)(off & 0xFFFFFFFFL);
+    const DWORD dwFileOffsetHigh = (sizeof(off_t) <= sizeof(DWORD)) ?
+                    (DWORD)0 : (DWORD)((off >> 32) & 0xFFFFFFFFL);
+    const DWORD protect = __map_mmap_prot_page(prot);
+    const DWORD desiredAccess = __map_mmap_prot_file(prot);
+
+    const off_t maxSize = off + (off_t)len;
+
+    const DWORD dwMaxSizeLow = (sizeof(off_t) <= sizeof(DWORD)) ? 
+                    (DWORD)maxSize : (DWORD)(maxSize & 0xFFFFFFFFL);
+    const DWORD dwMaxSizeHigh = (sizeof(off_t) <= sizeof(DWORD)) ?
+                    (DWORD)0 : (DWORD)((maxSize >> 32) & 0xFFFFFFFFL);
+
+#ifdef _MSC_VER
+#pragma warning(pop)
+#endif
+
+    errno = 0;
+    
+    if (len == 0 
+        /* Unsupported flag combinations */
+        || (flags & MAP_FIXED) != 0
+        /* Usupported protection combinations */
+        || prot == PROT_EXEC)
+    {
+        errno = EINVAL;
+        return MAP_FAILED;
+    }
+    
+    h = ((flags & MAP_ANONYMOUS) == 0) ? 
+                    (HANDLE)_get_osfhandle(fildes) : INVALID_HANDLE_VALUE;
+
+    if ((flags & MAP_ANONYMOUS) == 0 && h == INVALID_HANDLE_VALUE)
+    {
+        errno = EBADF;
+        return MAP_FAILED;
+    }
+
+    fm = CreateFileMapping(h, NULL, protect, dwMaxSizeHigh, dwMaxSizeLow, NULL);
+
+    if (fm == NULL)
+    {
+        errno = __map_mman_error(GetLastError(), EPERM);
+        return MAP_FAILED;
+    }
+  
+    map = MapViewOfFile(fm, desiredAccess, dwFileOffsetHigh, dwFileOffsetLow, len);
+
+    CloseHandle(fm);
+  
+    if (map == NULL)
+    {
+        errno = __map_mman_error(GetLastError(), EPERM);
+        return MAP_FAILED;
+    }
+
+    return map;
+}
+
+inline int munmap(void *addr, size_t len)
+{
+    if (UnmapViewOfFile(addr))
+        return 0;
+        
+    errno =  __map_mman_error(GetLastError(), EPERM);
+    
+    return -1;
+}
+
+inline int mprotect(void *addr, size_t len, int prot)
+{
+    DWORD newProtect = __map_mmap_prot_page(prot);
+    DWORD oldProtect = 0;
+    
+    if (VirtualProtect(addr, len, newProtect, &oldProtect))
+        return 0;
+    
+    errno =  __map_mman_error(GetLastError(), EPERM);
+    
+    return -1;
+}
+
+inline int msync(void *addr, size_t len, int flags)
+{
+    if (FlushViewOfFile(addr, len))
+        return 0;
+    
+    errno =  __map_mman_error(GetLastError(), EPERM);
+    
+    return -1;
+}
+
+inline int mlock(const void *addr, size_t len)
+{
+    if (VirtualLock((LPVOID)addr, len))
+        return 0;
+        
+    errno =  __map_mman_error(GetLastError(), EPERM);
+    
+    return -1;
+}
+
+inline int munlock(const void *addr, size_t len)
+{
+    if (VirtualUnlock((LPVOID)addr, len))
+        return 0;
+        
+    errno =  __map_mman_error(GetLastError(), EPERM);
+    
+    return -1;
+}
+
+#if !defined(__MINGW32__)
+inline int ftruncate(const int fd, const int64_t size) {
+    if (fd < 0) {
+        errno = EBADF;
+        return -1;
+    }
+
+    HANDLE h = reinterpret_cast<HANDLE>(_get_osfhandle(fd));
+    LARGE_INTEGER li_start, li_size;
+    li_start.QuadPart = static_cast<int64_t>(0);
+    li_size.QuadPart = size;
+    if (SetFilePointerEx(h, li_start, NULL, FILE_CURRENT) == ~0 ||
+        SetFilePointerEx(h, li_size, NULL, FILE_BEGIN) == ~0 ||
+        !SetEndOfFile(h)) {
+        unsigned long error = GetLastError();
+        fprintf(stderr, "I/O error while truncating: %lu\n", error);
+        switch (error) {
+            case ERROR_INVALID_HANDLE:
+                errno = EBADF;
+                break;
+            default:
+                errno = EIO;
+                break;
+        }
+        return -1;
+    }        
+    return 0;
+}
+#endif
+
+#endif 

package/dist/index.d.ts

@@ -0,0 +1,28 @@
+export type Metric = "angular" | "euclidean" | "manhattan" | "dot";
+export interface NearestNeighborsResult {
+    neighbors: number[];
+    distances: number[];
+}
+export declare class AnnoyIndex {
+    private index;
+    constructor(f: number, metric?: Metric);
+    addItem(index: number, vector: number[]): void;
+    build(numTrees: number, numThreads?: number): void;
+    unbuild(): void;
+    save(filename: string, prefault?: boolean): void;
+    load(filename: string, prefault?: boolean): void;
+    unload(): void;
+    getDistance(i: number, j: number): number;
+    getNnsByItem(item: number, n: number, searchK: number, includeDistances: true): NearestNeighborsResult;
+    getNnsByItem(item: number, n: number, searchK?: number, includeDistances?: false): number[];
+    getNnsByVector(vector: number[], n: number, searchK: number, includeDistances: true): NearestNeighborsResult;
+    getNnsByVector(vector: number[], n: number, searchK?: number, includeDistances?: false): number[];
+    getNItems(): number;
+    getNTrees(): number;
+    getItem(item: number): number[];
+    setSeed(seed: number): void;
+    onDiskBuild(filename: string): void;
+    verbose(v: boolean): void;
+    getF(): number;
+}
+export default AnnoyIndex;

package/dist/index.js

@@ -0,0 +1,103 @@
+"use strict";
+var __createBinding = (this && this.__createBinding) || (Object.create ? (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    var desc = Object.getOwnPropertyDescriptor(m, k);
+    if (!desc || ("get" in desc ? !m.__esModule : desc.writable || desc.configurable)) {
+      desc = { enumerable: true, get: function() { return m[k]; } };
+    }
+    Object.defineProperty(o, k2, desc);
+}) : (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    o[k2] = m[k];
+}));
+var __setModuleDefault = (this && this.__setModuleDefault) || (Object.create ? (function(o, v) {
+    Object.defineProperty(o, "default", { enumerable: true, value: v });
+}) : function(o, v) {
+    o["default"] = v;
+});
+var __importStar = (this && this.__importStar) || (function () {
+    var ownKeys = function(o) {
+        ownKeys = Object.getOwnPropertyNames || function (o) {
+            var ar = [];
+            for (var k in o) if (Object.prototype.hasOwnProperty.call(o, k)) ar[ar.length] = k;
+            return ar;
+        };
+        return ownKeys(o);
+    };
+    return function (mod) {
+        if (mod && mod.__esModule) return mod;
+        var result = {};
+        if (mod != null) for (var k = ownKeys(mod), i = 0; i < k.length; i++) if (k[i] !== "default") __createBinding(result, mod, k[i]);
+        __setModuleDefault(result, mod);
+        return result;
+    };
+})();
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.AnnoyIndex = void 0;
+const path = __importStar(require("path"));
+const addon = require(path.join(__dirname, "..", "build", "Release", "annoy.node"));
+class AnnoyIndex {
+    constructor(f, metric = "angular") {
+        const constructors = {
+            angular: addon.AnnoyIndexAngular,
+            euclidean: addon.AnnoyIndexEuclidean,
+            manhattan: addon.AnnoyIndexManhattan,
+            dot: addon.AnnoyIndexDotProduct,
+        };
+        const Ctor = constructors[metric];
+        if (!Ctor) {
+            throw new Error(`Unknown metric "${metric}". Use: angular, euclidean, manhattan, dot`);
+        }
+        this.index = new Ctor(f);
+    }
+    addItem(index, vector) {
+        this.index.addItem(index, vector);
+    }
+    build(numTrees, numThreads = -1) {
+        this.index.build(numTrees, numThreads);
+    }
+    unbuild() {
+        this.index.unbuild();
+    }
+    save(filename, prefault = false) {
+        this.index.save(filename, prefault);
+    }
+    load(filename, prefault = false) {
+        this.index.load(filename, prefault);
+    }
+    unload() {
+        this.index.unload();
+    }
+    getDistance(i, j) {
+        return this.index.getDistance(i, j);
+    }
+    getNnsByItem(item, n, searchK = -1, includeDistances = false) {
+        return this.index.getNnsByItem(item, n, searchK, includeDistances);
+    }
+    getNnsByVector(vector, n, searchK = -1, includeDistances = false) {
+        return this.index.getNnsByVector(vector, n, searchK, includeDistances);
+    }
+    getNItems() {
+        return this.index.getNItems();
+    }
+    getNTrees() {
+        return this.index.getNTrees();
+    }
+    getItem(item) {
+        return this.index.getItem(item);
+    }
+    setSeed(seed) {
+        this.index.setSeed(seed);
+    }
+    onDiskBuild(filename) {
+        this.index.onDiskBuild(filename);
+    }
+    verbose(v) {
+        this.index.verbose(v);
+    }
+    getF() {
+        return this.index.getF();
+    }
+}
+exports.AnnoyIndex = AnnoyIndex;
+exports.default = AnnoyIndex;

package/dist/test.d.ts

@@ -0,0 +1 @@
+export {};

package/dist/test.js

@@ -0,0 +1,171 @@
+"use strict";
+var __createBinding = (this && this.__createBinding) || (Object.create ? (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    var desc = Object.getOwnPropertyDescriptor(m, k);
+    if (!desc || ("get" in desc ? !m.__esModule : desc.writable || desc.configurable)) {
+      desc = { enumerable: true, get: function() { return m[k]; } };
+    }
+    Object.defineProperty(o, k2, desc);
+}) : (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    o[k2] = m[k];
+}));
+var __setModuleDefault = (this && this.__setModuleDefault) || (Object.create ? (function(o, v) {
+    Object.defineProperty(o, "default", { enumerable: true, value: v });
+}) : function(o, v) {
+    o["default"] = v;
+});
+var __importStar = (this && this.__importStar) || (function () {
+    var ownKeys = function(o) {
+        ownKeys = Object.getOwnPropertyNames || function (o) {
+            var ar = [];
+            for (var k in o) if (Object.prototype.hasOwnProperty.call(o, k)) ar[ar.length] = k;
+            return ar;
+        };
+        return ownKeys(o);
+    };
+    return function (mod) {
+        if (mod && mod.__esModule) return mod;
+        var result = {};
+        if (mod != null) for (var k = ownKeys(mod), i = 0; i < k.length; i++) if (k[i] !== "default") __createBinding(result, mod, k[i]);
+        __setModuleDefault(result, mod);
+        return result;
+    };
+})();
+Object.defineProperty(exports, "__esModule", { value: true });
+const index_1 = require("./index");
+const fs = __importStar(require("fs"));
+const path = __importStar(require("path"));
+const DIMS = 40;
+const NUM_ITEMS = 1000;
+const NUM_TREES = 10;
+const tmpFile = path.join(__dirname, "..", "test_index.ann");
+let passed = 0;
+let failed = 0;
+function assert(condition, msg) {
+    if (condition) {
+        passed++;
+        console.log(`  PASS: ${msg}`);
+    }
+    else {
+        failed++;
+        console.error(`  FAIL: ${msg}`);
+    }
+}
+function randomVector(dims) {
+    return Array.from({ length: dims }, () => Math.random() * 2 - 1);
+}
+function cleanup() {
+    try {
+        fs.unlinkSync(tmpFile);
+    }
+    catch { }
+}
+console.log("=== annoy-node test suite ===\n");
+// Test 1: Basic build and query (Angular)
+console.log("Test 1: Build and query (Angular)");
+{
+    const index = new index_1.AnnoyIndex(DIMS, "angular");
+    for (let i = 0; i < NUM_ITEMS; i++) {
+        index.addItem(i, randomVector(DIMS));
+    }
+    index.build(NUM_TREES);
+    assert(index.getNItems() === NUM_ITEMS, `getNItems() === ${NUM_ITEMS}`);
+    assert(index.getNTrees() === NUM_TREES, `getNTrees() === ${NUM_TREES}`);
+    assert(index.getF() === DIMS, `getF() === ${DIMS}`);
+    const neighbors = index.getNnsByItem(0, 10);
+    assert(Array.isArray(neighbors), "getNnsByItem returns array");
+    assert(neighbors.length === 10, "returns 10 neighbors");
+    assert(neighbors[0] === 0, "nearest neighbor of item 0 is itself");
+}
+// Test 2: Include distances
+console.log("\nTest 2: Include distances");
+{
+    const index = new index_1.AnnoyIndex(DIMS, "angular");
+    for (let i = 0; i < 100; i++) {
+        index.addItem(i, randomVector(DIMS));
+    }
+    index.build(NUM_TREES);
+    const result = index.getNnsByItem(0, 5, -1, true);
+    assert("neighbors" in result && "distances" in result, "result has neighbors and distances");
+    assert(result.neighbors.length === 5, "5 neighbors returned");
+    assert(result.distances.length === 5, "5 distances returned");
+    assert(result.distances[0] === 0, "distance to self is 0");
+}
+// Test 3: getNnsByVector
+console.log("\nTest 3: getNnsByVector");
+{
+    const index = new index_1.AnnoyIndex(DIMS, "euclidean");
+    const vectors = [];
+    for (let i = 0; i < 100; i++) {
+        const v = randomVector(DIMS);
+        vectors.push(v);
+        index.addItem(i, v);
+    }
+    index.build(NUM_TREES);
+    const result = index.getNnsByVector(vectors[0], 5);
+    assert(Array.isArray(result), "getNnsByVector returns array");
+    assert(result[0] === 0, "closest to vector[0] is item 0");
+}
+// Test 4: Save and load
+console.log("\nTest 4: Save and load");
+{
+    cleanup();
+    const index = new index_1.AnnoyIndex(DIMS, "angular");
+    for (let i = 0; i < 100; i++) {
+        index.addItem(i, randomVector(DIMS));
+    }
+    index.build(NUM_TREES);
+    index.save(tmpFile);
+    const loaded = new index_1.AnnoyIndex(DIMS, "angular");
+    loaded.load(tmpFile);
+    assert(loaded.getNItems() === 100, "loaded index has 100 items");
+    assert(loaded.getNTrees() === NUM_TREES, `loaded index has ${NUM_TREES} trees`);
+    const item = loaded.getItem(0);
+    assert(item.length === DIMS, `getItem returns vector of length ${DIMS}`);
+    cleanup();
+}
+// Test 5: getDistance
+console.log("\nTest 5: getDistance");
+{
+    const index = new index_1.AnnoyIndex(DIMS, "euclidean");
+    const v = randomVector(DIMS);
+    index.addItem(0, v);
+    index.addItem(1, v);
+    index.build(1);
+    const dist = index.getDistance(0, 1);
+    assert(Math.abs(dist) < 1e-6, `distance between identical vectors is ~0 (got ${dist})`);
+}
+// Test 6: All metrics
+console.log("\nTest 6: All metrics");
+{
+    const metrics = ["angular", "euclidean", "manhattan", "dot"];
+    for (const metric of metrics) {
+        const index = new index_1.AnnoyIndex(DIMS, metric);
+        for (let i = 0; i < 50; i++) {
+            index.addItem(i, randomVector(DIMS));
+        }
+        index.build(5);
+        const nn = index.getNnsByItem(0, 5);
+        assert(nn.length === 5, `${metric}: returns 5 neighbors`);
+    }
+}
+// Test 7: setSeed reproducibility
+console.log("\nTest 7: setSeed reproducibility");
+{
+    const vectors = Array.from({ length: 100 }, () => randomVector(DIMS));
+    function buildWithSeed(seed) {
+        const idx = new index_1.AnnoyIndex(DIMS, "angular");
+        idx.setSeed(seed);
+        for (let i = 0; i < 100; i++) {
+            idx.addItem(i, vectors[i]);
+        }
+        idx.build(5);
+        return idx.getNnsByItem(0, 10);
+    }
+    const r1 = buildWithSeed(42);
+    const r2 = buildWithSeed(42);
+    assert(JSON.stringify(r1) === JSON.stringify(r2), "same seed produces same results");
+}
+console.log(`\n=== Results: ${passed} passed, ${failed} failed ===`);
+process.exit(failed > 0 ? 1 : 0);