@elarsaks/umap-wasm 0.1.0

package/dist/src/heap.js

@@ -0,0 +1,226 @@
+"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.makeHeap = makeHeap;
+exports.rejectionSample = rejectionSample;
+exports.heapPush = heapPush;
+exports.uncheckedHeapPush = uncheckedHeapPush;
+exports.buildCandidates = buildCandidates;
+exports.deheapSort = deheapSort;
+exports.smallestFlagged = smallestFlagged;
+var utils = __importStar(require("./utils"));
+function makeHeap(nPoints, size) {
+    var makeArrays = function (fillValue) {
+        return utils.empty(nPoints).map(function () {
+            return utils.filled(size, fillValue);
+        });
+    };
+    var heap = [];
+    heap.push(makeArrays(-1));
+    heap.push(makeArrays(Infinity));
+    heap.push(makeArrays(0));
+    return heap;
+}
+function rejectionSample(nSamples, poolSize, random) {
+    var result = utils.zeros(nSamples);
+    for (var i = 0; i < nSamples; i++) {
+        var rejectSample = true;
+        var j = 0;
+        while (rejectSample) {
+            j = utils.tauRandInt(poolSize, random);
+            var broken = false;
+            for (var k = 0; k < i; k++) {
+                if (j === result[k]) {
+                    broken = true;
+                    break;
+                }
+            }
+            if (!broken)
+                rejectSample = false;
+        }
+        result[i] = j;
+    }
+    return result;
+}
+function heapPush(heap, row, weight, index, flag) {
+    row = Math.floor(row);
+    var indices = heap[0][row];
+    var weights = heap[1][row];
+    var isNew = heap[2][row];
+    if (weight >= weights[0]) {
+        return 0;
+    }
+    for (var i = 0; i < indices.length; i++) {
+        if (index === indices[i]) {
+            return 0;
+        }
+    }
+    return uncheckedHeapPush(heap, row, weight, index, flag);
+}
+function uncheckedHeapPush(heap, row, weight, index, flag) {
+    var indices = heap[0][row];
+    var weights = heap[1][row];
+    var isNew = heap[2][row];
+    if (weight >= weights[0]) {
+        return 0;
+    }
+    weights[0] = weight;
+    indices[0] = index;
+    isNew[0] = flag;
+    var i = 0;
+    var iSwap = 0;
+    while (true) {
+        var ic1 = 2 * i + 1;
+        var ic2 = ic1 + 1;
+        var heapShape2 = heap[0][0].length;
+        if (ic1 >= heapShape2) {
+            break;
+        }
+        else if (ic2 >= heapShape2) {
+            if (weights[ic1] > weight) {
+                iSwap = ic1;
+            }
+            else {
+                break;
+            }
+        }
+        else if (weights[ic1] >= weights[ic2]) {
+            if (weight < weights[ic1]) {
+                iSwap = ic1;
+            }
+            else {
+                break;
+            }
+        }
+        else {
+            if (weight < weights[ic2]) {
+                iSwap = ic2;
+            }
+            else {
+                break;
+            }
+        }
+        weights[i] = weights[iSwap];
+        indices[i] = indices[iSwap];
+        isNew[i] = isNew[iSwap];
+        i = iSwap;
+    }
+    weights[i] = weight;
+    indices[i] = index;
+    isNew[i] = flag;
+    return 1;
+}
+function buildCandidates(currentGraph, nVertices, nNeighbors, maxCandidates, random) {
+    var candidateNeighbors = makeHeap(nVertices, maxCandidates);
+    for (var i = 0; i < nVertices; i++) {
+        for (var j = 0; j < nNeighbors; j++) {
+            if (currentGraph[0][i][j] < 0) {
+                continue;
+            }
+            var idx = currentGraph[0][i][j];
+            var isn = currentGraph[2][i][j];
+            var d = utils.tauRand(random);
+            heapPush(candidateNeighbors, i, d, idx, isn);
+            heapPush(candidateNeighbors, idx, d, i, isn);
+            currentGraph[2][i][j] = 0;
+        }
+    }
+    return candidateNeighbors;
+}
+function deheapSort(heap) {
+    var indices = heap[0];
+    var weights = heap[1];
+    for (var i = 0; i < indices.length; i++) {
+        var indHeap = indices[i];
+        var distHeap = weights[i];
+        for (var j = 0; j < indHeap.length - 1; j++) {
+            var indHeapIndex = indHeap.length - j - 1;
+            var distHeapIndex = distHeap.length - j - 1;
+            var temp1 = indHeap[0];
+            indHeap[0] = indHeap[indHeapIndex];
+            indHeap[indHeapIndex] = temp1;
+            var temp2 = distHeap[0];
+            distHeap[0] = distHeap[distHeapIndex];
+            distHeap[distHeapIndex] = temp2;
+            siftDown(distHeap, indHeap, distHeapIndex, 0);
+        }
+    }
+    return { indices: indices, weights: weights };
+}
+function siftDown(heap1, heap2, ceiling, elt) {
+    while (elt * 2 + 1 < ceiling) {
+        var leftChild = elt * 2 + 1;
+        var rightChild = leftChild + 1;
+        var swap = elt;
+        if (heap1[swap] < heap1[leftChild]) {
+            swap = leftChild;
+        }
+        if (rightChild < ceiling && heap1[swap] < heap1[rightChild]) {
+            swap = rightChild;
+        }
+        if (swap === elt) {
+            break;
+        }
+        else {
+            var temp1 = heap1[elt];
+            heap1[elt] = heap1[swap];
+            heap1[swap] = temp1;
+            var temp2 = heap2[elt];
+            heap2[elt] = heap2[swap];
+            heap2[swap] = temp2;
+            elt = swap;
+        }
+    }
+}
+function smallestFlagged(heap, row) {
+    var ind = heap[0][row];
+    var dist = heap[1][row];
+    var flag = heap[2][row];
+    var minDist = Infinity;
+    var resultIndex = -1;
+    for (var i = 0; i > ind.length; i++) {
+        if (flag[i] === 1 && dist[i] < minDist) {
+            minDist = dist[i];
+            resultIndex = i;
+        }
+    }
+    if (resultIndex >= 0) {
+        flag[resultIndex] = 0;
+        return Math.floor(ind[resultIndex]);
+    }
+    else {
+        return -1;
+    }
+}

package/dist/src/index.d.ts

@@ -0,0 +1 @@
+export { UMAP, UMAPParameters } from './umap';

package/dist/src/index.js

@@ -0,0 +1,5 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.UMAP = void 0;
+var umap_1 = require("./umap");
+Object.defineProperty(exports, "UMAP", { enumerable: true, get: function () { return umap_1.UMAP; } });

package/dist/src/lib.d.ts

@@ -0,0 +1 @@
+export { UMAP } from './umap';

package/dist/src/lib.js

@@ -0,0 +1,5 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.UMAP = void 0;
+var umap_1 = require("./umap");
+Object.defineProperty(exports, "UMAP", { enumerable: true, get: function () { return umap_1.UMAP; } });

package/dist/src/matrix.d.ts

@@ -0,0 +1,41 @@
+export declare class SparseMatrix {
+    private entries;
+    readonly nRows: number;
+    readonly nCols: number;
+    constructor(rows: number[], cols: number[], values: number[], dims: number[]);
+    private makeKey;
+    private checkDims;
+    set(row: number, col: number, value: number): void;
+    get(row: number, col: number, defaultValue?: number): number;
+    getAll(ordered?: boolean): {
+        value: number;
+        row: number;
+        col: number;
+    }[];
+    getDims(): number[];
+    getRows(): number[];
+    getCols(): number[];
+    getValues(): number[];
+    forEach(fn: (value: number, row: number, col: number) => void): void;
+    map(fn: (value: number, row: number, col: number) => number): SparseMatrix;
+    toArray(): number[][];
+}
+export declare function transpose(matrix: SparseMatrix): SparseMatrix;
+export declare function identity(size: number[]): SparseMatrix;
+export declare function pairwiseMultiply(a: SparseMatrix, b: SparseMatrix): SparseMatrix;
+export declare function add(a: SparseMatrix, b: SparseMatrix): SparseMatrix;
+export declare function subtract(a: SparseMatrix, b: SparseMatrix): SparseMatrix;
+export declare function maximum(a: SparseMatrix, b: SparseMatrix): SparseMatrix;
+export declare function multiplyScalar(a: SparseMatrix, scalar: number): SparseMatrix;
+export declare function eliminateZeros(m: SparseMatrix): SparseMatrix;
+export declare function normalize(m: SparseMatrix, normType?: NormType): SparseMatrix;
+export declare const enum NormType {
+    max = "max",
+    l1 = "l1",
+    l2 = "l2"
+}
+export declare function getCSR(x: SparseMatrix): {
+    indices: number[];
+    values: number[];
+    indptr: number[];
+};

package/dist/src/matrix.js

@@ -0,0 +1,360 @@
+"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;
+    };
+})();
+var __read = (this && this.__read) || function (o, n) {
+    var m = typeof Symbol === "function" && o[Symbol.iterator];
+    if (!m) return o;
+    var i = m.call(o), r, ar = [], e;
+    try {
+        while ((n === void 0 || n-- > 0) && !(r = i.next()).done) ar.push(r.value);
+    }
+    catch (error) { e = { error: error }; }
+    finally {
+        try {
+            if (r && !r.done && (m = i["return"])) m.call(i);
+        }
+        finally { if (e) throw e.error; }
+    }
+    return ar;
+};
+var __values = (this && this.__values) || function(o) {
+    var s = typeof Symbol === "function" && Symbol.iterator, m = s && o[s], i = 0;
+    if (m) return m.call(o);
+    if (o && typeof o.length === "number") return {
+        next: function () {
+            if (o && i >= o.length) o = void 0;
+            return { value: o && o[i++], done: !o };
+        }
+    };
+    throw new TypeError(s ? "Object is not iterable." : "Symbol.iterator is not defined.");
+};
+var _a;
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.SparseMatrix = void 0;
+exports.transpose = transpose;
+exports.identity = identity;
+exports.pairwiseMultiply = pairwiseMultiply;
+exports.add = add;
+exports.subtract = subtract;
+exports.maximum = maximum;
+exports.multiplyScalar = multiplyScalar;
+exports.eliminateZeros = eliminateZeros;
+exports.normalize = normalize;
+exports.getCSR = getCSR;
+var utils = __importStar(require("./utils"));
+var SparseMatrix = (function () {
+    function SparseMatrix(rows, cols, values, dims) {
+        this.entries = new Map();
+        this.nRows = 0;
+        this.nCols = 0;
+        if (rows.length !== cols.length || rows.length !== values.length) {
+            throw new Error('rows, cols and values arrays must all have the same length');
+        }
+        this.nRows = dims[0];
+        this.nCols = dims[1];
+        for (var i = 0; i < values.length; i++) {
+            var row = rows[i];
+            var col = cols[i];
+            this.checkDims(row, col);
+            var key = this.makeKey(row, col);
+            this.entries.set(key, { value: values[i], row: row, col: col });
+        }
+    }
+    SparseMatrix.prototype.makeKey = function (row, col) {
+        return "".concat(row, ":").concat(col);
+    };
+    SparseMatrix.prototype.checkDims = function (row, col) {
+        var withinBounds = row < this.nRows && col < this.nCols;
+        if (!withinBounds) {
+            throw new Error('row and/or col specified outside of matrix dimensions');
+        }
+    };
+    SparseMatrix.prototype.set = function (row, col, value) {
+        this.checkDims(row, col);
+        var key = this.makeKey(row, col);
+        if (!this.entries.has(key)) {
+            this.entries.set(key, { value: value, row: row, col: col });
+        }
+        else {
+            this.entries.get(key).value = value;
+        }
+    };
+    SparseMatrix.prototype.get = function (row, col, defaultValue) {
+        if (defaultValue === void 0) { defaultValue = 0; }
+        this.checkDims(row, col);
+        var key = this.makeKey(row, col);
+        if (this.entries.has(key)) {
+            return this.entries.get(key).value;
+        }
+        else {
+            return defaultValue;
+        }
+    };
+    SparseMatrix.prototype.getAll = function (ordered) {
+        if (ordered === void 0) { ordered = true; }
+        var rowColValues = [];
+        this.entries.forEach(function (value) {
+            rowColValues.push(value);
+        });
+        if (ordered) {
+            rowColValues.sort(function (a, b) {
+                if (a.row === b.row) {
+                    return a.col - b.col;
+                }
+                else {
+                    return a.row - b.row;
+                }
+            });
+        }
+        return rowColValues;
+    };
+    SparseMatrix.prototype.getDims = function () {
+        return [this.nRows, this.nCols];
+    };
+    SparseMatrix.prototype.getRows = function () {
+        return Array.from(this.entries, function (_a) {
+            var _b = __read(_a, 2), key = _b[0], value = _b[1];
+            return value.row;
+        });
+    };
+    SparseMatrix.prototype.getCols = function () {
+        return Array.from(this.entries, function (_a) {
+            var _b = __read(_a, 2), key = _b[0], value = _b[1];
+            return value.col;
+        });
+    };
+    SparseMatrix.prototype.getValues = function () {
+        return Array.from(this.entries, function (_a) {
+            var _b = __read(_a, 2), key = _b[0], value = _b[1];
+            return value.value;
+        });
+    };
+    SparseMatrix.prototype.forEach = function (fn) {
+        this.entries.forEach(function (value) { return fn(value.value, value.row, value.col); });
+    };
+    SparseMatrix.prototype.map = function (fn) {
+        var vals = [];
+        this.entries.forEach(function (value) {
+            vals.push(fn(value.value, value.row, value.col));
+        });
+        var dims = [this.nRows, this.nCols];
+        return new SparseMatrix(this.getRows(), this.getCols(), vals, dims);
+    };
+    SparseMatrix.prototype.toArray = function () {
+        var _this = this;
+        var rows = utils.empty(this.nRows);
+        var output = rows.map(function () {
+            return utils.zeros(_this.nCols);
+        });
+        this.entries.forEach(function (value) {
+            output[value.row][value.col] = value.value;
+        });
+        return output;
+    };
+    return SparseMatrix;
+}());
+exports.SparseMatrix = SparseMatrix;
+function transpose(matrix) {
+    var cols = [];
+    var rows = [];
+    var vals = [];
+    matrix.forEach(function (value, row, col) {
+        cols.push(row);
+        rows.push(col);
+        vals.push(value);
+    });
+    var dims = [matrix.nCols, matrix.nRows];
+    return new SparseMatrix(rows, cols, vals, dims);
+}
+function identity(size) {
+    var _a = __read(size, 1), rows = _a[0];
+    var matrix = new SparseMatrix([], [], [], size);
+    for (var i = 0; i < rows; i++) {
+        matrix.set(i, i, 1);
+    }
+    return matrix;
+}
+function pairwiseMultiply(a, b) {
+    return elementWise(a, b, function (x, y) { return x * y; });
+}
+function add(a, b) {
+    return elementWise(a, b, function (x, y) { return x + y; });
+}
+function subtract(a, b) {
+    return elementWise(a, b, function (x, y) { return x - y; });
+}
+function maximum(a, b) {
+    return elementWise(a, b, function (x, y) { return (x > y ? x : y); });
+}
+function multiplyScalar(a, scalar) {
+    return a.map(function (value) {
+        return value * scalar;
+    });
+}
+function eliminateZeros(m) {
+    var zeroIndices = new Set();
+    var values = m.getValues();
+    var rows = m.getRows();
+    var cols = m.getCols();
+    for (var i = 0; i < values.length; i++) {
+        if (values[i] === 0) {
+            zeroIndices.add(i);
+        }
+    }
+    var removeByZeroIndex = function (_, index) { return !zeroIndices.has(index); };
+    var nextValues = values.filter(removeByZeroIndex);
+    var nextRows = rows.filter(removeByZeroIndex);
+    var nextCols = cols.filter(removeByZeroIndex);
+    return new SparseMatrix(nextRows, nextCols, nextValues, m.getDims());
+}
+function normalize(m, normType) {
+    var e_1, _a;
+    if (normType === void 0) { normType = "l2"; }
+    var normFn = normFns[normType];
+    var colsByRow = new Map();
+    m.forEach(function (_, row, col) {
+        var cols = colsByRow.get(row) || [];
+        cols.push(col);
+        colsByRow.set(row, cols);
+    });
+    var nextMatrix = new SparseMatrix([], [], [], m.getDims());
+    var _loop_1 = function (row) {
+        var cols = colsByRow.get(row).sort();
+        var vals = cols.map(function (col) { return m.get(row, col); });
+        var norm = normFn(vals);
+        for (var i = 0; i < norm.length; i++) {
+            nextMatrix.set(row, cols[i], norm[i]);
+        }
+    };
+    try {
+        for (var _b = __values(colsByRow.keys()), _c = _b.next(); !_c.done; _c = _b.next()) {
+            var row = _c.value;
+            _loop_1(row);
+        }
+    }
+    catch (e_1_1) { e_1 = { error: e_1_1 }; }
+    finally {
+        try {
+            if (_c && !_c.done && (_a = _b.return)) _a.call(_b);
+        }
+        finally { if (e_1) throw e_1.error; }
+    }
+    return nextMatrix;
+}
+var normFns = (_a = {},
+    _a["max"] = function (xs) {
+        var max = -Infinity;
+        for (var i = 0; i < xs.length; i++) {
+            max = xs[i] > max ? xs[i] : max;
+        }
+        return xs.map(function (x) { return x / max; });
+    },
+    _a["l1"] = function (xs) {
+        var sum = 0;
+        for (var i = 0; i < xs.length; i++) {
+            sum += xs[i];
+        }
+        return xs.map(function (x) { return x / sum; });
+    },
+    _a["l2"] = function (xs) {
+        var sum = 0;
+        for (var i = 0; i < xs.length; i++) {
+            sum += Math.pow(xs[i], 2);
+        }
+        return xs.map(function (x) { return Math.sqrt(Math.pow(x, 2) / sum); });
+    },
+    _a);
+function elementWise(a, b, op) {
+    var visited = new Set();
+    var rows = [];
+    var cols = [];
+    var vals = [];
+    var operate = function (row, col) {
+        rows.push(row);
+        cols.push(col);
+        var nextValue = op(a.get(row, col), b.get(row, col));
+        vals.push(nextValue);
+    };
+    var valuesA = a.getValues();
+    var rowsA = a.getRows();
+    var colsA = a.getCols();
+    for (var i = 0; i < valuesA.length; i++) {
+        var row = rowsA[i];
+        var col = colsA[i];
+        var key = "".concat(row, ":").concat(col);
+        visited.add(key);
+        operate(row, col);
+    }
+    var valuesB = b.getValues();
+    var rowsB = b.getRows();
+    var colsB = b.getCols();
+    for (var i = 0; i < valuesB.length; i++) {
+        var row = rowsB[i];
+        var col = colsB[i];
+        var key = "".concat(row, ":").concat(col);
+        if (visited.has(key))
+            continue;
+        operate(row, col);
+    }
+    var dims = [a.nRows, a.nCols];
+    return new SparseMatrix(rows, cols, vals, dims);
+}
+function getCSR(x) {
+    var entries = [];
+    x.forEach(function (value, row, col) {
+        entries.push({ value: value, row: row, col: col });
+    });
+    entries.sort(function (a, b) {
+        if (a.row === b.row) {
+            return a.col - b.col;
+        }
+        else {
+            return a.row - b.row;
+        }
+    });
+    var indices = [];
+    var values = [];
+    var indptr = [];
+    var currentRow = -1;
+    for (var i = 0; i < entries.length; i++) {
+        var _a = entries[i], row = _a.row, col = _a.col, value = _a.value;
+        if (row !== currentRow) {
+            currentRow = row;
+            indptr.push(i);
+        }
+        indices.push(col);
+        values.push(value);
+    }
+    return { indices: indices, values: values, indptr: indptr };
+}

package/dist/src/nn_descent.d.ts

@@ -0,0 +1,17 @@
+import * as heap from './heap';
+import * as matrix from './matrix';
+import * as tree from './tree';
+import { RandomFn, Vectors, DistanceFn } from './umap';
+export declare function makeNNDescent(distanceFn: DistanceFn, random: RandomFn): (data: Vectors, leafArray: Vectors, nNeighbors: number, nIters?: number, maxCandidates?: number, delta?: number, rho?: number, rpTreeInit?: boolean) => {
+    indices: number[][];
+    weights: number[][];
+};
+export type InitFromRandomFn = (nNeighbors: number, data: Vectors, queryPoints: Vectors, _heap: heap.Heap, random: RandomFn) => void;
+export type InitFromTreeFn = (_tree: tree.FlatTree, data: Vectors, queryPoints: Vectors, _heap: heap.Heap, random: RandomFn) => void;
+export declare function makeInitializations(distanceFn: DistanceFn): {
+    initFromRandom: (nNeighbors: number, data: Vectors, queryPoints: Vectors, _heap: heap.Heap, random: RandomFn) => void;
+    initFromTree: (_tree: tree.FlatTree, data: Vectors, queryPoints: Vectors, _heap: heap.Heap, random: RandomFn) => void;
+};
+export type SearchFn = (data: Vectors, graph: matrix.SparseMatrix, initialization: heap.Heap, queryPoints: Vectors) => heap.Heap;
+export declare function makeInitializedNNSearch(distanceFn: DistanceFn): (data: Vectors, graph: matrix.SparseMatrix, initialization: heap.Heap, queryPoints: Vectors) => heap.Heap;
+export declare function initializeSearch(forest: tree.FlatTree[], data: Vectors, queryPoints: Vectors, nNeighbors: number, initFromRandom: InitFromRandomFn, initFromTree: InitFromTreeFn, random: RandomFn): heap.Heap;