@johnhenry/math 0.0.0

package/dist/VectorUtils.js

@@ -0,0 +1,706 @@
+import { Vector } from "./Vector.js";
+export class VectorUtils {
+    // -- Section I.1: truth functions & comparison ---------------------------
+    static isVector(e) {
+        return e instanceof Vector;
+    }
+    static isNotVector(e) {
+        return !(e instanceof Vector);
+    }
+    /**
+     * True when the vector contains at least one element satisfying
+     * `vectorCriterion` (default: is a Vector).
+     *
+     * Bug fix: the AS3 implementation returned true only when *every* element was
+     * a vector, contradicting the library's own glossary ("multi-dimensional … if
+     * it contains elements which are also vectors") and breaking {@link flatten}
+     * on ragged/mixed vectors. The documented semantics are used here.
+     */
+    static isMultiDimensional(vector, vectorCriterion = VectorUtils.isVector) {
+        for (const e of vector) {
+            if (vectorCriterion(e))
+                return true;
+        }
+        return false;
+    }
+    /** True when `element` is present, optionally by a custom equality function. */
+    static contains(vector, element, equalityFunction) {
+        if (!equalityFunction)
+            return vector.lastIndexOf(element) !== -1;
+        for (const i of vector) {
+            if (equalityFunction(element, i))
+                return true;
+        }
+        return false;
+    }
+    /** The longer of two vectors; ties return the first. */
+    static longer(alpha, beta) {
+        return alpha.length >= beta.length ? alpha : beta;
+    }
+    /** The shorter of two vectors; ties return the second. */
+    static shorter(alpha, beta) {
+        return alpha.length >= beta.length ? beta : alpha;
+    }
+    static isNotMultiDimensional(vector, vectorCriterion) {
+        return !VectorUtils.isMultiDimensional(vector, vectorCriterion ?? VectorUtils.isVector);
+    }
+    static isFlat(vector, vectorCriterion) {
+        return VectorUtils.isNotMultiDimensional(vector, vectorCriterion);
+    }
+    // -- Section I.2: constructors -------------------------------------------
+    /** Arithmetic sequence `seed, seed+step, …` bounded by `limit`. */
+    static arithmeticSequence(seed = 0, limit = 100, step = 1) {
+        const out = new Vector();
+        let value = seed;
+        if (step > 0) {
+            if (limit < value)
+                limit = value;
+            while (value <= limit) {
+                out.push(value);
+                value += step;
+            }
+        }
+        else if (step < 0) {
+            if (limit > value)
+                limit = value;
+            while (value >= limit) {
+                out.push(value);
+                value += step;
+            }
+        }
+        else {
+            out.push(value);
+        }
+        return out;
+    }
+    /** `size` equally-spaced steps from `lower` to `upper` (inclusive). */
+    static arithmeticBounds(lower, upper, size) {
+        return VectorUtils.arithmeticSequence(lower, upper, (upper - lower) / size);
+    }
+    /** Geometric sequence `seed, seed*step, …` bounded by `|limit|`. */
+    static geometricSequence(seed = 1, limit = 1000, step = 2) {
+        const out = new Vector();
+        let value = seed;
+        if (Math.abs(step) > 1) {
+            if (Math.abs(limit) < Math.abs(value))
+                limit = value;
+            while (value <= Math.abs(limit)) {
+                out.push(value);
+                value *= step;
+            }
+        }
+        else if (Math.abs(step) < 1 && step !== 0) {
+            if (Math.abs(limit) < Math.abs(value))
+                limit = value;
+            while (value >= Math.abs(limit)) {
+                out.push(value);
+                value *= step;
+            }
+        }
+        else {
+            out.push(value);
+        }
+        return out;
+    }
+    /** A vector of `length` copies of `e`. */
+    static constantVector(length = 1, e) {
+        const out = new Vector();
+        for (let i = 0; i < length; i++)
+            out.push(e);
+        return out;
+    }
+    /** Wrap an array into a Vector. */
+    static fromArray(array) {
+        return Vector.fromArray(array);
+    }
+    /**
+     * Merge two elements into a single vector. Vectors are concatenated; a
+     * non-vector is folded into a vector partner; two non-vectors become a pair.
+     */
+    static merge(vectorA = null, vectorB = null) {
+        if (vectorA instanceof Vector && vectorB instanceof Vector) {
+            return Vector.fromArray([...vectorA, ...vectorB]);
+        }
+        if (vectorA instanceof Vector) {
+            const copy = vectorA.clone();
+            copy.push(vectorB);
+            return copy;
+        }
+        if (vectorB instanceof Vector) {
+            const copy = vectorB.clone();
+            copy.addElement(vectorA, 0); // bug fix: prepend vectorA, not vectorB
+            return copy;
+        }
+        return Vector.fromArray([vectorA, vectorB]);
+    }
+    /**
+     * Build a sequence recursively. With `keep`, the growing result feeds itself;
+     * otherwise a fixed-length sliding window of `seeds` is used. Neither the
+     * caller's `seeds` array is mutated (a bug avoided from the AS3 original).
+     */
+    static recursiveSequence(seeds, formula, endCondition, keep = false) {
+        const out = Vector.fromArray(seeds);
+        if (keep) {
+            // Pass the accumulator directly (not a fresh copy each time): the
+            // "caller's seeds untouched" guarantee only needs to protect the
+            // original `seeds` array (already copied into `out` above), not this
+            // internal accumulator. Spreading `out` on every push made this loop
+            // quadratic for large results.
+            while (!endCondition(out))
+                out.push(formula(out));
+        }
+        else {
+            const window = [...seeds];
+            while (!endCondition(window)) {
+                out.push(formula(window));
+                window.shift();
+                window.push(out[out.length - 1]);
+            }
+        }
+        return out;
+    }
+    /** Wrap `element` inside `depth` nested vectors. Returns `element` if depth 0. */
+    static wrap(element, depth = 1) {
+        if (depth === 0)
+            return element;
+        const out = new Vector();
+        out.push(element);
+        return VectorUtils.wrap(out, depth - 1);
+    }
+    /**
+     * Placeholder for the AS3 On-Line Encyclopedia of Integer Sequences fetch,
+     * which was itself only a hard-coded stub (it "required an internet
+     * connection" but never actually made one).
+     */
+    static fromOEIS(selection = 1) {
+        let vectorString;
+        switch (selection) {
+            case 1:
+                vectorString = "1,2,3";
+                break;
+            case 2:
+                vectorString = "4,5,6";
+                break;
+            case 3:
+                vectorString = "7,8,9";
+                break;
+            default:
+                vectorString = "0,0,0";
+        }
+        return VectorUtils.transform(Vector.fromArray(vectorString.split(",")), (s) => parseInt(s, 10));
+    }
+    // -- Section I.3: transformations ----------------------------------------
+    /** Fill a length-`v.length` vector with `unary(i)` for each index. */
+    static fillByIndex(v, unaryOperation) {
+        const out = new Vector(v.length);
+        for (let i = 0; i < out.length; i++)
+            out[i] = unaryOperation(i);
+        return out;
+    }
+    /** Map `unaryOperation` over each element. */
+    static transform(vector, unaryOperation) {
+        const out = new Vector();
+        for (const e of vector)
+            out.push(unaryOperation(e));
+        return out;
+    }
+    /** Replace every element with `element`. */
+    static replace(vector, element) {
+        const out = new Vector();
+        for (let i = 0; i < vector.length; i++)
+            out.push(element);
+        return out;
+    }
+    /** Map `unaryOperation` over every end node (non-vector leaf), recursively. */
+    static transformEndNodes(vector, unaryOperation, endNodeCriterion = VectorUtils.isNotVector) {
+        const out = vector.clone();
+        for (let i = 0; i < out.length; i++) {
+            const el = out[i];
+            if (endNodeCriterion(el) || !(el instanceof Vector)) {
+                out[i] = unaryOperation(el);
+            }
+            else {
+                out[i] = VectorUtils.transformEndNodes(el, unaryOperation, endNodeCriterion);
+            }
+        }
+        return out;
+    }
+    /** Replace every end node with `element`, recursively. */
+    static replaceEndNodes(vector, element, endNodeCriterion = VectorUtils.isNotVector) {
+        const out = vector.clone();
+        for (let i = 0; i < out.length; i++) {
+            const el = out[i];
+            if (endNodeCriterion(el) || !(el instanceof Vector)) {
+                out[i] = element;
+            }
+            else {
+                out[i] = VectorUtils.replaceEndNodes(el, element, endNodeCriterion);
+            }
+        }
+        return out;
+    }
+    /** Remove `first` elements from the front and `last` from the back. */
+    static trim(vector, first = 0, last = 0) {
+        const out = vector.clone();
+        out.splice(vector.length - last, last);
+        out.splice(0, first);
+        return out;
+    }
+    /** Remove every occurrence of any of `remove` (strict equality). */
+    static removeElements(vector, ...remove) {
+        const out = vector.clone();
+        for (let i = 0; i < out.length; i++) {
+            if (remove.includes(out[i])) {
+                out.removeElement(i);
+                i--;
+            }
+        }
+        return out;
+    }
+    /** Keep the elements matching `matchCriterion`. */
+    static filter(vector, matchCriterion) {
+        const out = new Vector();
+        for (const e of vector)
+            if (matchCriterion(e))
+                out.push(e);
+        return out;
+    }
+    /** The most frequently occurring element(s). */
+    static modes(list) {
+        const modes = new Vector();
+        if (list.length === 0)
+            return modes;
+        // Single linear pass with a Map (SameValueZero equality, matching the old
+        // Array#includes-based lookup) instead of an O(n) `includes` scan plus an
+        // O(n) `count` rescan per unique value.
+        const counts = new Map();
+        const order = [];
+        for (const value of list) {
+            const occurences = counts.get(value);
+            if (occurences === undefined) {
+                counts.set(value, 1);
+                order.push(value);
+            }
+            else {
+                counts.set(value, occurences + 1);
+            }
+        }
+        let highCount = 0;
+        for (const value of order) {
+            const occurences = counts.get(value);
+            if (occurences > highCount)
+                highCount = occurences;
+        }
+        for (const value of order) {
+            if (counts.get(value) === highCount)
+                modes.push(value);
+        }
+        return modes;
+    }
+    /** Fully flatten a nested vector of arbitrary, possibly ragged depth. */
+    static flatten(vector) {
+        // A single depth-first pass into a fresh output vector. The previous
+        // implementation repeatedly spliced elements into/out of a shared vector
+        // in place (`removeElement`/`addElement` are O(n) each), making it
+        // severely superlinear; this walk visits each leaf exactly once.
+        const out = new Vector();
+        const walk = (v) => {
+            for (const el of v) {
+                if (el instanceof Vector) {
+                    walk(el);
+                }
+                else {
+                    out.push(el);
+                }
+            }
+        };
+        walk(vector);
+        return out;
+    }
+    /** Flatten one level of a vector whose elements share the same depth. */
+    static flattenSD(vector) {
+        if (vector.length === 0)
+            return new Vector();
+        if (!(vector[0] instanceof Vector))
+            return vector.clone();
+        // One linear pass, spreading each vector element's own elements straight
+        // into a fresh output vector (matching `merge`'s vector+scalar behavior
+        // for any non-vector siblings). The previous implementation repeatedly
+        // called `merge` + deep `clone` on the ever-growing accumulator, an O(n)
+        // operation per element, making the whole pass quadratic.
+        const out = new Vector();
+        for (const el of vector) {
+            if (el instanceof Vector) {
+                for (const e of el)
+                    out.push(e);
+            }
+            else {
+                out.push(el);
+            }
+        }
+        return out;
+    }
+    /** Flatten a same-depth vector by `depth` levels (fully if `depth` is 0). */
+    static flattenSDLevels(vector, depth = 0) {
+        let out = vector.clone();
+        const level = depth > 0 ? depth : VectorUtils.nestedDepthSD(vector);
+        // Bug fix: this called `flatten` (unlimited, fully recursive), which made
+        // every `depth >= 1` produce the same fully-flat result on the first
+        // iteration — silently ignoring `depth`. `flattenSD` only peels one level
+        // per call, which is what "by `depth` levels" actually requires.
+        for (let i = 0; i < level; i++)
+            out = VectorUtils.flattenSD(out);
+        return out;
+    }
+    /** Replace end nodes with copies of the whole vector (one fractal step). */
+    static fractal(vector) {
+        return VectorUtils.replaceEndNodes(vector, vector.clone());
+    }
+    /** Apply {@link fractal} `level` times. */
+    static fractalLevels(vector, level = 0) {
+        let out = vector.clone();
+        for (let i = 0; i < level; i++)
+            out = VectorUtils.fractal(out);
+        return out;
+    }
+    // -- Section I.4: combinations -------------------------------------------
+    /** Insert the elements of `newVector` into `target` at `index`. */
+    static insert(target, newVector, index = -1) {
+        if (index < 0)
+            index = target.length;
+        const out = target.clone();
+        for (let i = 0; i < newVector.length; i++) {
+            out.splice(index + i, 0, newVector[i]);
+        }
+        return out;
+    }
+    /**
+     * Combine two vectors element-wise via `binaryOperation`. Where only one
+     * vector has an element, `defaultValue` is used if supplied, otherwise the
+     * present element. (Bug fix: presence is tested by index, not truthiness.)
+     */
+    static combine(alpha, beta, binaryOperation, defaultValue) {
+        const len = Math.max(alpha.length, beta.length);
+        const out = new Vector(len);
+        for (let i = 0; i < len; i++) {
+            const hasA = i < alpha.length;
+            const hasB = i < beta.length;
+            if (hasA && hasB) {
+                out[i] = binaryOperation(alpha[i], beta[i]);
+            }
+            else if (hasA) {
+                out[i] = defaultValue !== undefined ? defaultValue : alpha[i];
+            }
+            else {
+                out[i] = defaultValue !== undefined ? defaultValue : beta[i];
+            }
+        }
+        return out;
+    }
+    // -- Section I.5: reductions & queries -----------------------------------
+    static length(list) {
+        return list.length;
+    }
+    /** Reduce a vector to a single value via a binary operation (left fold). */
+    static collapse(vector, binaryOperation, defaultObject = null) {
+        const work = vector.clone();
+        if (work.length === 0)
+            return defaultObject;
+        let acc = work[0];
+        for (let i = 1; i < work.length; i++)
+            acc = binaryOperation(acc, work[i]);
+        return acc;
+    }
+    /** Count elements satisfying `matchCriterion`. */
+    static matches(vector, matchCriterion) {
+        let n = 0;
+        for (const e of vector)
+            if (matchCriterion(e))
+                n++;
+        return n;
+    }
+    /** Count occurrences of `matchElement` (strict equality). */
+    static count(vector, matchElement) {
+        return VectorUtils.matches(vector, (x) => x === matchElement);
+    }
+    /**
+     * Lengths of consecutive runs matching `matchCriterion`. Unlike the AS3
+     * original, a spurious trailing `0` (left over when the input ends on a
+     * non-matching run) is trimmed.
+     */
+    static consecutiveMatches(vector, matchCriterion) {
+        const appearences = [0];
+        for (const e of vector) {
+            if (matchCriterion(e)) {
+                appearences[appearences.length - 1]++;
+            }
+            else if (appearences[appearences.length - 1] !== 0) {
+                appearences.push(0);
+            }
+        }
+        if (appearences.length > 1 && appearences[appearences.length - 1] === 0)
+            appearences.pop();
+        return appearences;
+    }
+    /** Depth of a same-depth nested vector. */
+    static nestedDepthSD(vector, initialDepth = 0) {
+        if (!(vector[0] instanceof Vector))
+            return initialDepth;
+        return VectorUtils.nestedDepthSD(vector[0], initialDepth + 1);
+    }
+    // -- Section III: matrices -----------------------------------------------
+    /** Row separator used by {@link matrixString}. */
+    static RowSeperator = ",\r";
+    /** True when `vector` is a matrix (rows are equal-length vectors). */
+    static isMatrix(vector) {
+        if (!(vector[0] instanceof Vector))
+            return false;
+        const length = vector[0].length;
+        for (const v of vector) {
+            if (!(v instanceof Vector) || v.length !== length)
+                return false;
+        }
+        return true;
+    }
+    static width(vector) {
+        return vector[0].length;
+    }
+    static height(vector) {
+        return vector.length;
+    }
+    /** An `height`×`width` matrix filled with `e`. */
+    static constantMatrix(height = 1, width = 1, e) {
+        const out = new Vector();
+        for (let i = 0; i < height; i++) {
+            const row = new Vector();
+            for (let j = 0; j < width; j++)
+                row.push(e);
+            out.push(row);
+        }
+        return out;
+    }
+    /** Identity-like matrix with `one` on the diagonal and `zero` elsewhere. */
+    static generateIdentity(height = 1, width = 1, one, zero) {
+        const identity = VectorUtils.constantMatrix(height, width, zero);
+        return VectorUtils.fillMatrixByIndex(identity, (i, j) => (i === j ? one : zero));
+    }
+    /** Wrap a vector as a single-row matrix. */
+    static vectorToMatrixRow(vector) {
+        const out = new Vector();
+        out.push(vector);
+        return out;
+    }
+    /** Wrap a vector as a single-column matrix. */
+    static vectorToMatrixColumn(vector) {
+        return VectorUtils.transpose(VectorUtils.vectorToMatrixRow(vector));
+    }
+    /** Fill each cell of a matrix with `binaryOperation(i, j)`. */
+    static fillMatrixByIndex(m, binaryOperation) {
+        const out = m.clone();
+        for (let i = 0; i < VectorUtils.height(out); i++) {
+            for (let j = 0; j < VectorUtils.width(out); j++) {
+                out[i][j] = binaryOperation(i, j);
+            }
+        }
+        return out;
+    }
+    /** Replace every cell of a matrix with `element`. */
+    static replaceMatrix(m, element) {
+        const out = m.clone();
+        for (let i = 0; i < VectorUtils.height(out); i++) {
+            for (let j = 0; j < VectorUtils.width(out); j++)
+                out[i][j] = element;
+        }
+        return out;
+    }
+    /** Transpose a matrix. */
+    static transpose(vector) {
+        const out = new Vector();
+        for (let k = 0; k < VectorUtils.width(vector); k++)
+            out.push(new Vector(VectorUtils.height(vector)));
+        for (let i = 0; i < VectorUtils.height(vector); i++) {
+            for (let j = 0; j < VectorUtils.width(vector); j++) {
+                out[j][i] = vector[i][j];
+            }
+        }
+        return out;
+    }
+    /** Return the `index`-th row as a single-row matrix. */
+    static getRow(m, index = 0) {
+        return VectorUtils.wrap(m[index]);
+    }
+    /** Return the `index`-th column as a single-row matrix. */
+    static getColumn(m, index = 0) {
+        return VectorUtils.transpose(VectorUtils.getRow(VectorUtils.transpose(m), index));
+    }
+    static rowRemoved(m, index = 0) {
+        const out = m.clone();
+        out.removeElement(index);
+        return out;
+    }
+    static columnRemoved(m, index = 0) {
+        return VectorUtils.transpose(VectorUtils.rowRemoved(VectorUtils.transpose(m), index));
+    }
+    static rowInserted(target, inserted, index = -1) {
+        return VectorUtils.insert(target, VectorUtils.wrap(inserted), index);
+    }
+    static columnInserted(target, inserted, index = -1) {
+        return VectorUtils.transpose(VectorUtils.rowInserted(VectorUtils.transpose(target), inserted, index));
+    }
+    static mergeRows(vectorA, vectorB) {
+        return VectorUtils.merge(vectorA, vectorB);
+    }
+    static mergeColumns(vectorA, vectorB) {
+        return VectorUtils.transpose(VectorUtils.mergeRows(VectorUtils.transpose(vectorA), VectorUtils.transpose(vectorB)));
+    }
+    static rowSet(target, newVector, index = 0) {
+        const out = target.clone();
+        out.setElement(newVector, index);
+        return out;
+    }
+    static columnSet(target, newVector, index = 0) {
+        return VectorUtils.transpose(VectorUtils.rowSet(VectorUtils.transpose(target), newVector, index));
+    }
+    /** Overlay `block` onto `target` with its top-left corner at (i, j). */
+    static placeBlock(target, block, i, j) {
+        const out = target.clone();
+        for (let iPrime = 0; iPrime < VectorUtils.height(block); iPrime++) {
+            for (let jPrime = 0; jPrime < VectorUtils.width(block); jPrime++) {
+                const row = out[i + iPrime];
+                if (row && row.length > j + jPrime) {
+                    row[j + jPrime] = block[iPrime][jPrime];
+                }
+            }
+        }
+        return out;
+    }
+    /** Expand a block matrix (matrix of matrices) into a flat matrix. */
+    static breakBlock(M) {
+        let newHeight = 0;
+        let newWidth = 0;
+        const h = VectorUtils.height(M);
+        const w = VectorUtils.width(M);
+        for (let k = 0; k < h; k++)
+            newHeight += VectorUtils.height(M[k][0]);
+        for (let k = 0; k < w; k++)
+            newWidth += VectorUtils.width(M[0][k]);
+        const broken = VectorUtils.constantMatrix(newHeight, newWidth, null);
+        let currentHeight = 0;
+        let currentWidth = 0;
+        let currentMatrix = M[0][0];
+        while (currentHeight < newHeight) {
+            for (let i = 0; i < h; i++) {
+                for (let j = 0; j < w; j++) {
+                    currentMatrix = M[i][j];
+                    for (let iPrime = 0; iPrime < VectorUtils.height(currentMatrix); iPrime++) {
+                        for (let jPrime = 0; jPrime < VectorUtils.width(currentMatrix); jPrime++) {
+                            broken[currentHeight + iPrime][currentWidth + jPrime] = currentMatrix[iPrime][jPrime];
+                        }
+                    }
+                    currentWidth += VectorUtils.width(currentMatrix);
+                }
+                currentWidth = 0;
+                currentHeight += VectorUtils.height(currentMatrix);
+            }
+        }
+        return broken;
+    }
+    /** Pad a matrix with `element`, optionally interleaving and/or bordering. */
+    static pad(matrix, element = null, padRows = true, padCols = true, top = true, bottom = true, left = true, right = true) {
+        let out = matrix.clone();
+        let paddingVector;
+        if (padRows) {
+            let insertCount = 1;
+            while (insertCount < VectorUtils.height(out)) {
+                paddingVector = VectorUtils.constantVector(VectorUtils.width(out), element);
+                out = VectorUtils.rowInserted(out, paddingVector, insertCount);
+                insertCount += 2;
+            }
+        }
+        if (padCols) {
+            let insertCount = 1;
+            while (insertCount < VectorUtils.width(out)) {
+                paddingVector = VectorUtils.constantVector(VectorUtils.height(out), element);
+                out = VectorUtils.columnInserted(out, paddingVector, insertCount);
+                insertCount += 2;
+            }
+        }
+        if (top)
+            out = VectorUtils.rowInserted(out, VectorUtils.constantVector(VectorUtils.width(out), element), 0);
+        if (bottom)
+            out = VectorUtils.rowInserted(out, VectorUtils.constantVector(VectorUtils.width(out), element), -1);
+        if (left)
+            out = VectorUtils.columnInserted(out, VectorUtils.constantVector(VectorUtils.height(out), element), 0);
+        if (right)
+            out = VectorUtils.columnInserted(out, VectorUtils.constantVector(VectorUtils.height(out), element), -1);
+        return out;
+    }
+    /** The main (or `off`-set) diagonal of a matrix as a vector. */
+    static diagonal(M, off = 0) {
+        const diag = new Vector();
+        if (off >= 0) {
+            for (let i = 0; i < VectorUtils.width(M) - off; i++)
+                diag.push(M[i][i + off]);
+        }
+        else {
+            const o = -off;
+            for (let i = 0; i < VectorUtils.height(M) - o; i++)
+                diag.push(M[i + o][i]);
+        }
+        return diag;
+    }
+    /** The anti-diagonal (or `off`-set) of a matrix as a vector. */
+    static minorDiagonal(M, off = 0) {
+        const diag = new Vector();
+        if (off >= 0) {
+            for (let i = 0; i < VectorUtils.width(M) - off; i++) {
+                diag.push(M[i][VectorUtils.width(M) - i - 1 - off]);
+            }
+        }
+        else {
+            const o = -off;
+            for (let i = 0; i < VectorUtils.height(M) - o; i++) {
+                diag.push(M[i + o][VectorUtils.width(M) - i - 1]);
+            }
+        }
+        return diag;
+    }
+    /** Render a matrix as a nicely aligned multi-line string. */
+    static matrixString(vector, minSpace = 0, center = 0, seperator = ",", leftBracket = "[", rightBracket = "]", rowSeperator = ",", openingBracket = "[", closingBracket = "]") {
+        // Stringify cells (kept in a parallel structure so we don't mutate input).
+        const cells = [];
+        let space = minSpace;
+        for (let i = 0; i < VectorUtils.height(vector); i++) {
+            const row = [];
+            for (let j = 0; j < VectorUtils.width(vector); j++) {
+                const raw = vector[i][j];
+                const str = raw == null ? "null" : String(raw);
+                row.push(str);
+                if (minSpace > 0 && space < str.length)
+                    space = str.length;
+            }
+            cells.push(row);
+        }
+        if (minSpace > 0) {
+            for (const row of cells) {
+                for (let j = 0; j < row.length; j++) {
+                    const cell = row[j];
+                    if (center !== 0) {
+                        let addLeft = Math.ceil((space - cell.length) / 2);
+                        let addRight = Math.floor((space - cell.length) / 2);
+                        if (center < 0)
+                            [addLeft, addRight] = [addRight, addLeft];
+                        row[j] = " ".repeat(addLeft) + cell + " ".repeat(addRight);
+                    }
+                    else {
+                        row[j] = " ".repeat(space - cell.length) + cell;
+                    }
+                }
+            }
+        }
+        const rowStrings = cells.map((row) => leftBracket + row.join(seperator) + rightBracket);
+        const fullRowSep = `${rowSeperator}\r${" ".repeat(openingBracket.length)}`;
+        return openingBracket + rowStrings.join(fullRowSep) + closingBracket;
+    }
+}
+//# sourceMappingURL=VectorUtils.js.map