@datagrok/eda 1.4.4 → 1.4.6

package/dist/vendors-node_modules_keckelt_tsne_lib_index_js.js

@@ -1,379 +0,0 @@
-"use strict";
-(self["webpackChunkeda"] = self["webpackChunkeda"] || []).push([["vendors-node_modules_keckelt_tsne_lib_index_js"],{
-
-/***/ "./node_modules/@keckelt/tsne/lib/index.js":
-/*!*************************************************!*\
-  !*** ./node_modules/@keckelt/tsne/lib/index.js ***!
-  \*************************************************/
-/***/ ((__unused_webpack_module, exports, __webpack_require__) => {
-
-
-Object.defineProperty(exports, "__esModule", ({ value: true }));
-exports.TSNE = void 0;
-var tsne_1 = __webpack_require__(/*! ./tsne */ "./node_modules/@keckelt/tsne/lib/tsne.js");
-Object.defineProperty(exports, "TSNE", ({ enumerable: true, get: function () { return tsne_1.TSNE; } }));
-
-
-/***/ }),
-
-/***/ "./node_modules/@keckelt/tsne/lib/tsne.js":
-/*!************************************************!*\
-  !*** ./node_modules/@keckelt/tsne/lib/tsne.js ***!
-  \************************************************/
-/***/ ((__unused_webpack_module, exports) => {
-
-
-Object.defineProperty(exports, "__esModule", ({ value: true }));
-exports.TSNE = void 0;
-class TSNE {
-    constructor(opt) {
-        // return 0 mean unit standard deviation random number
-        this.returnV = false;
-        this.vValue = 0.0;
-        this.iter = 0;
-        opt = opt || {};
-        this.perplexity = this.getopt(opt, 'perplexity', 30); // effective number of nearest neighbors
-        this.dim = this.getopt(opt, 'dim', 2); // by default 2-D tSNE
-        this.epsilon = this.getopt(opt, 'epsilon', 10); // learning rate
-    }
-    assert(condition, message) {
-        if (!condition) {
-            throw message || 'Assertion failed';
-        }
-    }
-    // syntax sugar
-    getopt(opt, field, defaultval) {
-        if (opt.hasOwnProperty(field)) {
-            return opt[field];
-        }
-        else {
-            return defaultval;
-        }
-    }
-    gaussRandom() {
-        if (this.returnV) {
-            this.returnV = false;
-            return this.vValue;
-        }
-        const u = 2 * Math.random() - 1;
-        const v = 2 * Math.random() - 1;
-        const r = u * u + v * v;
-        if (r === 0 || r > 1) {
-            return this.gaussRandom();
-        }
-        const c = Math.sqrt(-2 * Math.log(r) / r);
-        this.vValue = v * c; // cache this for next function call for efficiency
-        this.returnV = true;
-        return u * c;
-    }
-    // return random normal number
-    randn(mu, std) { return mu + this.gaussRandom() * std; }
-    // utilitity that creates contiguous vector of zeros of size n
-    zeros(n) {
-        if (typeof (n) === 'undefined' || isNaN(n)) {
-            return [];
-        }
-        if (typeof ArrayBuffer === 'undefined') {
-            // lacking browser support
-            const arr = new Array(n);
-            for (let i = 0; i < n; i++) {
-                arr[i] = 0;
-            }
-            return arr;
-        }
-        else {
-            return new Float64Array(n); // typed arrays are faster
-        }
-    }
-    // utility that returns 2d array filled with random numbers
-    // or with value s, if provided
-    randn2d(n, d, s) {
-        const uses = typeof s !== 'undefined';
-        const x = [];
-        for (let i = 0; i < n; i++) {
-            const xhere = [];
-            for (let j = 0; j < d; j++) {
-                if (uses) {
-                    xhere.push(s);
-                }
-                else {
-                    xhere.push(this.randn(0.0, 1e-4));
-                }
-            }
-            x.push(xhere);
-        }
-        return x;
-    }
-    // compute L2 distance between two vectors
-    L2(x1, x2) {
-        const D = x1.length;
-        let d = 0;
-        for (let i = 0; i < D; i++) {
-            const x1i = x1[i];
-            const x2i = x2[i];
-            d += (x1i - x2i) * (x1i - x2i);
-        }
-        return d;
-    }
-    // compute pairwise distance in all vectors in X
-    xtod(X) {
-        const N = X.length;
-        const dist = this.zeros(N * N); // allocate contiguous array
-        for (let i = 0; i < N; i++) {
-            for (let j = i + 1; j < N; j++) {
-                const d = this.L2(X[i], X[j]);
-                dist[i * N + j] = d;
-                dist[j * N + i] = d;
-            }
-        }
-        return dist;
-    }
-    // compute (p_{i|j} + p_{j|i})/(2n)
-    d2p(D, perplexity, tol) {
-        const nf = Math.sqrt(D.length); // this better be an integer
-        const n = Math.floor(nf);
-        this.assert(n === nf, 'D should have square number of elements.');
-        const hTarget = Math.log(perplexity); // target entropy of distribution
-        const P = this.zeros(n * n); // temporary probability matrix
-        const prow = this.zeros(n); // a temporary storage compartment
-        for (let i = 0; i < n; i++) {
-            let betamin = -Infinity;
-            let betamax = Infinity;
-            let beta = 1; // initial value of precision
-            let done = false;
-            const maxtries = 50;
-            // perform binary search to find a suitable precision beta
-            // so that the entropy of the distribution is appropriate
-            let num = 0;
-            while (!done) {
-                //debugger;
-                // compute entropy and kernel row with beta precision
-                let psum = 0.0;
-                for (let j = 0; j < n; j++) {
-                    let pj = Math.exp(-D[i * n + j] * beta);
-                    if (i === j) {
-                        pj = 0;
-                    } // we dont care about diagonals
-                    prow[j] = pj;
-                    psum += pj;
-                }
-                // normalize p and compute entropy
-                let nHere = 0.0;
-                for (let j = 0; j < n; j++) {
-                    let pj;
-                    if (psum === 0) {
-                        pj = 0;
-                    }
-                    else {
-                        pj = prow[j] / psum;
-                    }
-                    prow[j] = pj;
-                    if (pj > 1e-7) {
-                        nHere -= pj * Math.log(pj);
-                    }
-                }
-                // adjust beta based on result
-                if (nHere > hTarget) {
-                    // entropy was too high (distribution too diffuse)
-                    // so we need to increase the precision for more peaky distribution
-                    betamin = beta; // move up the bounds
-                    if (betamax === Infinity) {
-                        beta = beta * 2;
-                    }
-                    else {
-                        beta = (beta + betamax) / 2;
-                    }
-                }
-                else {
-                    // converse case. make distrubtion less peaky
-                    betamax = beta;
-                    if (betamin === -Infinity) {
-                        beta = beta / 2;
-                    }
-                    else {
-                        beta = (beta + betamin) / 2;
-                    }
-                }
-                // stopping conditions: too many tries or got a good precision
-                num++;
-                if (Math.abs(nHere - hTarget) < tol) {
-                    done = true;
-                }
-                if (num >= maxtries) {
-                    done = true;
-                }
-            }
-            // console.log('data point ' + i + ' gets precision ' + beta + ' after ' + num + ' binary search steps.');
-            // copy over the final prow to P at row i
-            for (let j = 0; j < n; j++) {
-                P[i * n + j] = prow[j];
-            }
-        } // end loop over examples i
-        // symmetrize P and normalize it to sum to 1 over all ij
-        const pOut = this.zeros(n * n);
-        const N2 = n * 2;
-        for (let i = 0; i < n; i++) {
-            for (let j = 0; j < n; j++) {
-                pOut[i * n + j] = Math.max((P[i * n + j] + P[j * n + i]) / N2, 1e-100);
-            }
-        }
-        return pOut;
-    }
-    // helper function
-    sign(x) { return x > 0 ? 1 : x < 0 ? -1 : 0; }
-    // this function takes a set of high-dimensional points
-    // and creates matrix P from them using gaussian kernel
-    initDataRaw(X) {
-        const N = X.length;
-        const D = X[0].length;
-        this.assert(N > 0, ' X is empty? You must have some data!');
-        this.assert(D > 0, ' X[0] is empty? Where is the data?');
-        const dists = this.xtod(X); // convert X to distances using gaussian kernel
-        this.P = this.d2p(dists, this.perplexity, 1e-4); // attach to object
-        this.N = N; // back up the size of the dataset
-        this.initSolution(); // refresh this
-    }
-    // this function takes a given distance matrix and creates
-    // matrix P from them.
-    // D is assumed to be provided as a list of lists, and should be symmetric
-    initDataDist(D) {
-        const N = D.length;
-        this.assert(N > 0, ' X is empty? You must have some data!');
-        // convert D to a (fast) typed array version
-        const dists = this.zeros(N * N); // allocate contiguous array
-        for (let i = 0; i < N; i++) {
-            for (let j = i + 1; j < N; j++) {
-                const d = D[i][j];
-                dists[i * N + j] = d;
-                dists[j * N + i] = d;
-            }
-        }
-        this.P = this.d2p(dists, this.perplexity, 1e-4);
-        this.N = N;
-        this.initSolution(); // refresh this
-    }
-    // (re)initializes the solution to random
-    initSolution() {
-        // generate random solution to t-SNE
-        this.Y = this.randn2d(this.N, this.dim); // the solution
-        this.gains = this.randn2d(this.N, this.dim, 1.0); // step gains to accelerate progress in unchanging directions
-        this.ystep = this.randn2d(this.N, this.dim, 0.0); // momentum accumulator
-        this.iter = 0;
-    }
-    // return pointer to current solution
-    getSolution() {
-        return this.Y;
-    }
-    // perform a single step of optimization to improve the embedding
-    step() {
-        this.iter += 1;
-        const N = this.N;
-        const cg = this.costGrad(this.Y); // evaluate gradient
-        const cost = cg.cost;
-        const grad = cg.grad;
-        // perform gradient step
-        const ymean = this.zeros(this.dim);
-        for (let i = 0; i < N; i++) {
-            for (let d = 0; d < this.dim; d++) {
-                const gid = grad[i][d];
-                const sid = this.ystep[i][d];
-                const gainid = this.gains[i][d];
-                // compute gain update
-                let newgain = this.sign(gid) === this.sign(sid) ? gainid * 0.8 : gainid + 0.2;
-                if (newgain < 0.01) {
-                    newgain = 0.01;
-                } // clamp
-                this.gains[i][d] = newgain; // store for next turn
-                // compute momentum step direction
-                const momval = this.iter < 250 ? 0.5 : 0.8;
-                const newsid = momval * sid - this.epsilon * newgain * grad[i][d];
-                this.ystep[i][d] = newsid; // remember the step we took
-                // step!
-                this.Y[i][d] += newsid;
-                ymean[d] += this.Y[i][d]; // accumulate mean so that we can center later
-            }
-        }
-        // reproject Y to be zero mean
-        for (let i = 0; i < N; i++) {
-            for (let d = 0; d < this.dim; d++) {
-                this.Y[i][d] -= ymean[d] / N;
-            }
-        }
-        //if(this.iter%100===0) console.log('iter ' + this.iter + ', cost: ' + cost);
-        return cost; // return current cost
-    }
-    // for debugging: gradient check
-    debugGrad() {
-        const N = this.N;
-        const cg = this.costGrad(this.Y); // evaluate gradient
-        const cost = cg.cost;
-        const grad = cg.grad;
-        const e = 1e-5;
-        for (let i = 0; i < N; i++) {
-            for (let d = 0; d < this.dim; d++) {
-                const yold = this.Y[i][d];
-                this.Y[i][d] = yold + e;
-                const cg0 = this.costGrad(this.Y);
-                this.Y[i][d] = yold - e;
-                const cg1 = this.costGrad(this.Y);
-                const analytic = grad[i][d];
-                const numerical = (cg0.cost - cg1.cost) / (2 * e);
-                console.log(i + ',' + d + ': gradcheck analytic: ' + analytic + ' vs. numerical: ' + numerical);
-                this.Y[i][d] = yold;
-            }
-        }
-    }
-    // return cost and gradient, given an arrangement
-    costGrad(Y) {
-        const N = this.N;
-        const dim = this.dim; // dim of output space
-        const P = this.P;
-        const pmul = this.iter < 100 ? 4 : 1; // trick that helps with local optima
-        // compute current Q distribution, unnormalized first
-        const quArr = this.zeros(N * N);
-        let qsum = 0.0;
-        for (let i = 0; i < N; i++) {
-            for (let j = i + 1; j < N; j++) {
-                let dsum = 0.0;
-                for (let d = 0; d < dim; d++) {
-                    const dhere = Y[i][d] - Y[j][d];
-                    dsum += dhere * dhere;
-                }
-                const qu = 1.0 / (1.0 + dsum); // Student t-distribution
-                quArr[i * N + j] = qu;
-                quArr[j * N + i] = qu;
-                qsum += 2 * qu;
-            }
-        }
-        // normalize Q distribution to sum to 1
-        const NN = N * N;
-        const Q = this.zeros(NN);
-        for (let q = 0; q < NN; q++) {
-            Q[q] = Math.max(quArr[q] / qsum, 1e-100);
-        }
-        let cost = 0.0;
-        const grad = [];
-        for (let i = 0; i < N; i++) {
-            const gsum = new Array(dim); // init grad for point i
-            for (let d = 0; d < dim; d++) {
-                gsum[d] = 0.0;
-            }
-            for (let j = 0; j < N; j++) {
-                cost += -P[i * N + j] * Math.log(Q[i * N + j]); // accumulate cost (the non-constant portion at least...)
-                const premult = 4 * (pmul * P[i * N + j] - Q[i * N + j]) * quArr[i * N + j];
-                for (let d = 0; d < dim; d++) {
-                    gsum[d] += premult * (Y[i][d] - Y[j][d]);
-                }
-            }
-            grad.push(gsum);
-        }
-        return { cost, grad };
-    }
-}
-exports.TSNE = TSNE;
-
-
-/***/ })
-
-}]);
-//# sourceMappingURL=vendors-node_modules_keckelt_tsne_lib_index_js.js.map

package/dist/vendors-node_modules_keckelt_tsne_lib_index_js.js.map

@@ -1 +0,0 @@
-{"version":3,"file":"vendors-node_modules_keckelt_tsne_lib_index_js.js","mappings":";;;;;;;;;AAAa;AACb,8CAA6C,EAAE,aAAa,EAAC;AAC7D,YAAY;AACZ,aAAa,mBAAO,CAAC,wDAAQ;AAC7B,wCAAuC,EAAE,qCAAqC,uBAAuB,EAAC;;;;;;;;;;;ACJzF;AACb,8CAA6C,EAAE,aAAa,EAAC;AAC7D,YAAY;AACZ;AACA;AACA;AACA;AACA;AACA;AACA;AACA,8DAA8D;AAC9D,+CAA+C;AAC/C,wDAAwD;AACxD;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA,6BAA6B;AAC7B;AACA;AACA;AACA;AACA,qBAAqB;AACrB;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA,4BAA4B,OAAO;AACnC;AACA;AACA;AACA;AACA;AACA,wCAAwC;AACxC;AACA;AACA;AACA;AACA;AACA;AACA;AACA,wBAAwB,OAAO;AAC/B;AACA,4BAA4B,OAAO;AACnC;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA,wBAAwB,OAAO;AAC/B;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA,wCAAwC;AACxC,wBAAwB,OAAO;AAC/B,gCAAgC,OAAO;AACvC;AACA;AACA;AACA;AACA;AACA;AACA;AACA,mBAAmB,KAAK,KAAK,IAAI;AACjC;AACA,wCAAwC;AACxC;AACA;AACA,8CAA8C;AAC9C,qCAAqC;AACrC,oCAAoC;AACpC,wBAAwB,OAAO;AAC/B;AACA;AACA,0BAA0B;AAC1B;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA,gCAAgC,OAAO;AACvC;AACA;AACA;AACA,sBAAsB;AACtB;AACA;AACA;AACA;AACA;AACA,gCAAgC,OAAO;AACvC;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA,oCAAoC;AACpC;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA,4BAA4B,OAAO;AACnC;AACA;AACA,UAAU;AACV;AACA;AACA;AACA,wBAAwB,OAAO;AAC/B,4BAA4B,OAAO;AACnC;AACA;AACA;AACA;AACA;AACA;AACA,cAAc;AACd;AACA;AACA;AACA;AACA;AACA;AACA;AACA,oCAAoC;AACpC,yDAAyD;AACzD,oBAAoB;AACpB,6BAA6B;AAC7B;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA,yCAAyC;AACzC,wBAAwB,OAAO;AAC/B,gCAAgC,OAAO;AACvC;AACA;AACA;AACA;AACA;AACA;AACA;AACA,6BAA6B;AAC7B;AACA;AACA;AACA;AACA,iDAAiD;AACjD,0DAA0D;AAC1D,0DAA0D;AAC1D;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA,0CAA0C;AAC1C;AACA;AACA;AACA;AACA,wBAAwB,OAAO;AAC/B,4BAA4B,cAAc;AAC1C;AACA;AACA;AACA;AACA;AACA;AACA;AACA,kBAAkB;AAClB,4CAA4C;AAC5C;AACA;AACA;AACA,2CAA2C;AAC3C;AACA;AACA,0CAA0C;AAC1C;AACA;AACA;AACA,wBAAwB,OAAO;AAC/B,4BAA4B,cAAc;AAC1C;AACA;AACA;AACA;AACA,qBAAqB;AACrB;AACA;AACA;AACA;AACA,0CAA0C;AAC1C;AACA;AACA;AACA,wBAAwB,OAAO;AAC/B,4BAA4B,cAAc;AAC1C;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA,8BAA8B;AAC9B;AACA,8CAA8C;AAC9C;AACA;AACA;AACA,wBAAwB,OAAO;AAC/B,gCAAgC,OAAO;AACvC;AACA,gCAAgC,SAAS;AACzC;AACA;AACA;AACA,+CAA+C;AAC/C;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA,wBAAwB,QAAQ;AAChC;AACA;AACA;AACA;AACA,wBAAwB,OAAO;AAC/B,yCAAyC;AACzC,4BAA4B,SAAS;AACrC;AACA;AACA,4BAA4B,OAAO;AACnC,gEAAgE;AAChE;AACA,gCAAgC,SAAS;AACzC;AACA;AACA;AACA;AACA;AACA,iBAAiB;AACjB;AACA;AACA,YAAY","sources":["webpack://eda/./node_modules/@keckelt/tsne/lib/index.js","webpack://eda/./node_modules/@keckelt/tsne/lib/tsne.js"],"sourcesContent":["\"use strict\";\nObject.defineProperty(exports, \"__esModule\", { value: true });\nexports.TSNE = void 0;\nvar tsne_1 = require(\"./tsne\");\nObject.defineProperty(exports, \"TSNE\", { enumerable: true, get: function () { return tsne_1.TSNE; } });\n","\"use strict\";\nObject.defineProperty(exports, \"__esModule\", { value: true });\nexports.TSNE = void 0;\nclass TSNE {\n    constructor(opt) {\n        // return 0 mean unit standard deviation random number\n        this.returnV = false;\n        this.vValue = 0.0;\n        this.iter = 0;\n        opt = opt || {};\n        this.perplexity = this.getopt(opt, 'perplexity', 30); // effective number of nearest neighbors\n        this.dim = this.getopt(opt, 'dim', 2); // by default 2-D tSNE\n        this.epsilon = this.getopt(opt, 'epsilon', 10); // learning rate\n    }\n    assert(condition, message) {\n        if (!condition) {\n            throw message || 'Assertion failed';\n        }\n    }\n    // syntax sugar\n    getopt(opt, field, defaultval) {\n        if (opt.hasOwnProperty(field)) {\n            return opt[field];\n        }\n        else {\n            return defaultval;\n        }\n    }\n    gaussRandom() {\n        if (this.returnV) {\n            this.returnV = false;\n            return this.vValue;\n        }\n        const u = 2 * Math.random() - 1;\n        const v = 2 * Math.random() - 1;\n        const r = u * u + v * v;\n        if (r === 0 || r > 1) {\n            return this.gaussRandom();\n        }\n        const c = Math.sqrt(-2 * Math.log(r) / r);\n        this.vValue = v * c; // cache this for next function call for efficiency\n        this.returnV = true;\n        return u * c;\n    }\n    // return random normal number\n    randn(mu, std) { return mu + this.gaussRandom() * std; }\n    // utilitity that creates contiguous vector of zeros of size n\n    zeros(n) {\n        if (typeof (n) === 'undefined' || isNaN(n)) {\n            return [];\n        }\n        if (typeof ArrayBuffer === 'undefined') {\n            // lacking browser support\n            const arr = new Array(n);\n            for (let i = 0; i < n; i++) {\n                arr[i] = 0;\n            }\n            return arr;\n        }\n        else {\n            return new Float64Array(n); // typed arrays are faster\n        }\n    }\n    // utility that returns 2d array filled with random numbers\n    // or with value s, if provided\n    randn2d(n, d, s) {\n        const uses = typeof s !== 'undefined';\n        const x = [];\n        for (let i = 0; i < n; i++) {\n            const xhere = [];\n            for (let j = 0; j < d; j++) {\n                if (uses) {\n                    xhere.push(s);\n                }\n                else {\n                    xhere.push(this.randn(0.0, 1e-4));\n                }\n            }\n            x.push(xhere);\n        }\n        return x;\n    }\n    // compute L2 distance between two vectors\n    L2(x1, x2) {\n        const D = x1.length;\n        let d = 0;\n        for (let i = 0; i < D; i++) {\n            const x1i = x1[i];\n            const x2i = x2[i];\n            d += (x1i - x2i) * (x1i - x2i);\n        }\n        return d;\n    }\n    // compute pairwise distance in all vectors in X\n    xtod(X) {\n        const N = X.length;\n        const dist = this.zeros(N * N); // allocate contiguous array\n        for (let i = 0; i < N; i++) {\n            for (let j = i + 1; j < N; j++) {\n                const d = this.L2(X[i], X[j]);\n                dist[i * N + j] = d;\n                dist[j * N + i] = d;\n            }\n        }\n        return dist;\n    }\n    // compute (p_{i|j} + p_{j|i})/(2n)\n    d2p(D, perplexity, tol) {\n        const nf = Math.sqrt(D.length); // this better be an integer\n        const n = Math.floor(nf);\n        this.assert(n === nf, 'D should have square number of elements.');\n        const hTarget = Math.log(perplexity); // target entropy of distribution\n        const P = this.zeros(n * n); // temporary probability matrix\n        const prow = this.zeros(n); // a temporary storage compartment\n        for (let i = 0; i < n; i++) {\n            let betamin = -Infinity;\n            let betamax = Infinity;\n            let beta = 1; // initial value of precision\n            let done = false;\n            const maxtries = 50;\n            // perform binary search to find a suitable precision beta\n            // so that the entropy of the distribution is appropriate\n            let num = 0;\n            while (!done) {\n                //debugger;\n                // compute entropy and kernel row with beta precision\n                let psum = 0.0;\n                for (let j = 0; j < n; j++) {\n                    let pj = Math.exp(-D[i * n + j] * beta);\n                    if (i === j) {\n                        pj = 0;\n                    } // we dont care about diagonals\n                    prow[j] = pj;\n                    psum += pj;\n                }\n                // normalize p and compute entropy\n                let nHere = 0.0;\n                for (let j = 0; j < n; j++) {\n                    let pj;\n                    if (psum === 0) {\n                        pj = 0;\n                    }\n                    else {\n                        pj = prow[j] / psum;\n                    }\n                    prow[j] = pj;\n                    if (pj > 1e-7) {\n                        nHere -= pj * Math.log(pj);\n                    }\n                }\n                // adjust beta based on result\n                if (nHere > hTarget) {\n                    // entropy was too high (distribution too diffuse)\n                    // so we need to increase the precision for more peaky distribution\n                    betamin = beta; // move up the bounds\n                    if (betamax === Infinity) {\n                        beta = beta * 2;\n                    }\n                    else {\n                        beta = (beta + betamax) / 2;\n                    }\n                }\n                else {\n                    // converse case. make distrubtion less peaky\n                    betamax = beta;\n                    if (betamin === -Infinity) {\n                        beta = beta / 2;\n                    }\n                    else {\n                        beta = (beta + betamin) / 2;\n                    }\n                }\n                // stopping conditions: too many tries or got a good precision\n                num++;\n                if (Math.abs(nHere - hTarget) < tol) {\n                    done = true;\n                }\n                if (num >= maxtries) {\n                    done = true;\n                }\n            }\n            // console.log('data point ' + i + ' gets precision ' + beta + ' after ' + num + ' binary search steps.');\n            // copy over the final prow to P at row i\n            for (let j = 0; j < n; j++) {\n                P[i * n + j] = prow[j];\n            }\n        } // end loop over examples i\n        // symmetrize P and normalize it to sum to 1 over all ij\n        const pOut = this.zeros(n * n);\n        const N2 = n * 2;\n        for (let i = 0; i < n; i++) {\n            for (let j = 0; j < n; j++) {\n                pOut[i * n + j] = Math.max((P[i * n + j] + P[j * n + i]) / N2, 1e-100);\n            }\n        }\n        return pOut;\n    }\n    // helper function\n    sign(x) { return x > 0 ? 1 : x < 0 ? -1 : 0; }\n    // this function takes a set of high-dimensional points\n    // and creates matrix P from them using gaussian kernel\n    initDataRaw(X) {\n        const N = X.length;\n        const D = X[0].length;\n        this.assert(N > 0, ' X is empty? You must have some data!');\n        this.assert(D > 0, ' X[0] is empty? Where is the data?');\n        const dists = this.xtod(X); // convert X to distances using gaussian kernel\n        this.P = this.d2p(dists, this.perplexity, 1e-4); // attach to object\n        this.N = N; // back up the size of the dataset\n        this.initSolution(); // refresh this\n    }\n    // this function takes a given distance matrix and creates\n    // matrix P from them.\n    // D is assumed to be provided as a list of lists, and should be symmetric\n    initDataDist(D) {\n        const N = D.length;\n        this.assert(N > 0, ' X is empty? You must have some data!');\n        // convert D to a (fast) typed array version\n        const dists = this.zeros(N * N); // allocate contiguous array\n        for (let i = 0; i < N; i++) {\n            for (let j = i + 1; j < N; j++) {\n                const d = D[i][j];\n                dists[i * N + j] = d;\n                dists[j * N + i] = d;\n            }\n        }\n        this.P = this.d2p(dists, this.perplexity, 1e-4);\n        this.N = N;\n        this.initSolution(); // refresh this\n    }\n    // (re)initializes the solution to random\n    initSolution() {\n        // generate random solution to t-SNE\n        this.Y = this.randn2d(this.N, this.dim); // the solution\n        this.gains = this.randn2d(this.N, this.dim, 1.0); // step gains to accelerate progress in unchanging directions\n        this.ystep = this.randn2d(this.N, this.dim, 0.0); // momentum accumulator\n        this.iter = 0;\n    }\n    // return pointer to current solution\n    getSolution() {\n        return this.Y;\n    }\n    // perform a single step of optimization to improve the embedding\n    step() {\n        this.iter += 1;\n        const N = this.N;\n        const cg = this.costGrad(this.Y); // evaluate gradient\n        const cost = cg.cost;\n        const grad = cg.grad;\n        // perform gradient step\n        const ymean = this.zeros(this.dim);\n        for (let i = 0; i < N; i++) {\n            for (let d = 0; d < this.dim; d++) {\n                const gid = grad[i][d];\n                const sid = this.ystep[i][d];\n                const gainid = this.gains[i][d];\n                // compute gain update\n                let newgain = this.sign(gid) === this.sign(sid) ? gainid * 0.8 : gainid + 0.2;\n                if (newgain < 0.01) {\n                    newgain = 0.01;\n                } // clamp\n                this.gains[i][d] = newgain; // store for next turn\n                // compute momentum step direction\n                const momval = this.iter < 250 ? 0.5 : 0.8;\n                const newsid = momval * sid - this.epsilon * newgain * grad[i][d];\n                this.ystep[i][d] = newsid; // remember the step we took\n                // step!\n                this.Y[i][d] += newsid;\n                ymean[d] += this.Y[i][d]; // accumulate mean so that we can center later\n            }\n        }\n        // reproject Y to be zero mean\n        for (let i = 0; i < N; i++) {\n            for (let d = 0; d < this.dim; d++) {\n                this.Y[i][d] -= ymean[d] / N;\n            }\n        }\n        //if(this.iter%100===0) console.log('iter ' + this.iter + ', cost: ' + cost);\n        return cost; // return current cost\n    }\n    // for debugging: gradient check\n    debugGrad() {\n        const N = this.N;\n        const cg = this.costGrad(this.Y); // evaluate gradient\n        const cost = cg.cost;\n        const grad = cg.grad;\n        const e = 1e-5;\n        for (let i = 0; i < N; i++) {\n            for (let d = 0; d < this.dim; d++) {\n                const yold = this.Y[i][d];\n                this.Y[i][d] = yold + e;\n                const cg0 = this.costGrad(this.Y);\n                this.Y[i][d] = yold - e;\n                const cg1 = this.costGrad(this.Y);\n                const analytic = grad[i][d];\n                const numerical = (cg0.cost - cg1.cost) / (2 * e);\n                console.log(i + ',' + d + ': gradcheck analytic: ' + analytic + ' vs. numerical: ' + numerical);\n                this.Y[i][d] = yold;\n            }\n        }\n    }\n    // return cost and gradient, given an arrangement\n    costGrad(Y) {\n        const N = this.N;\n        const dim = this.dim; // dim of output space\n        const P = this.P;\n        const pmul = this.iter < 100 ? 4 : 1; // trick that helps with local optima\n        // compute current Q distribution, unnormalized first\n        const quArr = this.zeros(N * N);\n        let qsum = 0.0;\n        for (let i = 0; i < N; i++) {\n            for (let j = i + 1; j < N; j++) {\n                let dsum = 0.0;\n                for (let d = 0; d < dim; d++) {\n                    const dhere = Y[i][d] - Y[j][d];\n                    dsum += dhere * dhere;\n                }\n                const qu = 1.0 / (1.0 + dsum); // Student t-distribution\n                quArr[i * N + j] = qu;\n                quArr[j * N + i] = qu;\n                qsum += 2 * qu;\n            }\n        }\n        // normalize Q distribution to sum to 1\n        const NN = N * N;\n        const Q = this.zeros(NN);\n        for (let q = 0; q < NN; q++) {\n            Q[q] = Math.max(quArr[q] / qsum, 1e-100);\n        }\n        let cost = 0.0;\n        const grad = [];\n        for (let i = 0; i < N; i++) {\n            const gsum = new Array(dim); // init grad for point i\n            for (let d = 0; d < dim; d++) {\n                gsum[d] = 0.0;\n            }\n            for (let j = 0; j < N; j++) {\n                cost += -P[i * N + j] * Math.log(Q[i * N + j]); // accumulate cost (the non-constant portion at least...)\n                const premult = 4 * (pmul * P[i * N + j] - Q[i * N + j]) * quArr[i * N + j];\n                for (let d = 0; d < dim; d++) {\n                    gsum[d] += premult * (Y[i][d] - Y[j][d]);\n                }\n            }\n            grad.push(gsum);\n        }\n        return { cost, grad };\n    }\n}\nexports.TSNE = TSNE;\n"],"names":[],"sourceRoot":""}