flo-mat 3.0.14 → 4.0.1

package/src/dijkstra/dijkstra.ts

@@ -1,418 +0,0 @@
-// Modified by Floris
-/******************************************************************************
- * Created 2008-08-19.
- *
- * Dijkstra path-finding functions. Adapted from the Dijkstar Python project.
- *
- * Copyright (C) 2008
- *   Wyatt Baldwin <self@wyattbaldwin.com>
- *   All rights reserved
- *
- * Licensed under the MIT license.
- *
- *   http://www.opensource.org/licenses/mit-license.php
- *
- * THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
- * IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
- * FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
- * AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
- * LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
- * OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN
- * THE SOFTWARE.
- *****************************************************************************/
-
-// import { Heap } from "../heap/heap";
-/**
- * see [Wikipedia](https://en.wikipedia.org/wiki/Heap_(data_structure))
- * 
- * @internal
- */
-class Heap<T> {
-    public heap: T[] = [];
-
-    constructor(private compare: (a: T, b: T) => number) {}
-
-    public isEmpty() {
-        return this.heap.length === 0;
-    }
-
-    public insert(t: T): void {
-        const heap = this.heap;
-
-        heap.push(t);
-
-        // Swim up
-        let i = heap.length-1;
-        while (true) {
-            const parentIdx = (i - 1 - (i+1)%2)/2;
-            if (parentIdx === -1) { return; }
-
-            const parent = heap[parentIdx];
-            if (this.compare(t, parent) < 0) { 
-                break;
-            }
-            
-            // Swap and update indexes and variables
-            heap[parentIdx] = t;
-            heap[i] = parent;
-            i = parentIdx;
-        }
-    }
-
-
-    public popMax(): T {
-        const heap = this.heap;
-        const maxT = heap[0];
-        heap[0] = heap[heap.length - 1];
-        heap.length--;
-        this.swimDown();
-
-        return maxT;
-    }
-
-
-    private swimDown() {
-        const heap = this.heap;
-
-        const len = heap.length;
-    
-        let i = 0;
-        // Swim down
-        while (true) {
-            const leftIdx = 2*i + 1;
-            if (leftIdx >= len) { 
-                break;  // there's no left or right child
-            }
-            const rightIdx = 2*i + 2;
-
-            const swapIdx = (rightIdx >= len) || (this.compare(heap[leftIdx], heap[rightIdx]) > 0)
-                ? leftIdx
-                : rightIdx;
-
-            const swapChild = heap[swapIdx];
-
-            const parent = heap[i];    
-            if (this.compare(parent, swapChild) > 0) { 
-                break;
-            }
-
-            // Swap and update indexes
-            heap[swapIdx] = parent;
-            heap[i] = swapChild;
-            i = swapIdx;
-        }
-    }
-
-
-    public swapMinOrMax(t: T): void {
-        this.heap[0] = t;
-        this.swimDown();
-    }
-
-    /* ignore coverage */
-    public static getParentIdx(i: number) { return (i - 1 - (i+1)%2)/2; }
-    public static getLeftChild(i: number) { return 2*i + 1; }
-    public static getRightChild(i: number) { return 2*i + 2; }
-}
-
-
-interface NodeWithWeight<T> {
-    v: T;
-    w: number;
-}
-
-
-function compareNodeWithWeight<T>(
-        a: NodeWithWeight<T>,
-        b: NodeWithWeight<T>) {
-
-    return a.w - b.w;
-}
-
-
-type OGraph = { [index:string]: { [index:string]: number } };
-
-
-// function getOChildren(
-//         graph: OGraph) {
-
-//     return (
-
-//     )
-// }
-
-
-function singleSourceShortestPaths(
-        graph: OGraph,
-        s: string,
-        d?: string) {
-
-    // Predecessor map for each node that has been encountered.
-    // node ID => predecessor node ID
-    const predecessors: { [index:string]: string } = {};
-
-    // Costs of shortest paths from s to all nodes encountered.
-    // node ID => cost
-    const costs: { [index:string]: number } = {};
-    costs[s] = 0;
-
-    // Costs of shortest paths from s to all nodes encountered; differs from
-    // `costs` in that it provides easy access to the node that currently has
-    // the known shortest path from s.
-    // XXX: Do we actually need both `costs` and `open`?
-    const open = new Heap<NodeWithWeight<string>>(compareNodeWithWeight);
-    open.insert({ v: s, w: 0 });
-
-
-    while (!open.isEmpty()) {
-        // In the nodes remaining in graph that have a known cost from s,
-        // find the node, u, that currently has the shortest path from s.
-        const closest = open.popMax();
-        const u = closest.v;
-        const costOf_s_to_u = closest.w;
-
-        // Get nodes adjacent to u...
-        const adjacentNodes = graph[u] || {};
-
-        // ...and explore the edges that connect u to those nodes, updating
-        // the cost of the shortest paths to any or all of those nodes as
-        // necessary. v is the node across the current edge from u.
-        for (const v in adjacentNodes) {
-            if (adjacentNodes.hasOwnProperty(v)) {
-                // Get the cost of the edge running from u to v.
-                const costOf_e = adjacentNodes[v];
-
-                // Cost of s to u plus the cost of u to v across e--this is *a*
-                // cost from s to v that may or may not be less than the current
-                // known cost to v.
-                const costOf_s_to_u_PLUS_costOf_e = costOf_s_to_u + costOf_e;
-
-                // If we haven't visited v yet OR if the current known cost from s to
-                // v is greater than the new cost we just found (cost of s to u plus
-                // cost of u to v across e), update v's cost in the cost list and
-                // update v's predecessor in the predecessor list (it's now u).
-                const costOf_s_to_v = costs[v];
-                const firstVisit = (costs[v] === undefined);
-                if (firstVisit || costOf_s_to_v > costOf_s_to_u_PLUS_costOf_e) {
-                    costs[v] = costOf_s_to_u_PLUS_costOf_e;
-                    open.insert({ v, w: costOf_s_to_u_PLUS_costOf_e });
-                    predecessors[v] = u;
-                }
-            }
-        }
-    }
-
-    if (d !== undefined && costs[d] === undefined) {
-        const msg = ['Could not find a path from ', s, ' to ', d, '.'].join('');
-        throw new Error(msg);
-    }
-
-    return predecessors;
-}
-
-
-function extractShortestPathFromPredecessorList(
-        predecessors: { [index:string]: string },
-        d: string) {
-
-    const nodes = [];
-    let u = d;
-    while (u) {
-        nodes.push(u);
-        u = predecessors[u];
-    }
-    nodes.reverse();//?
-
-    return nodes;
-}
-
-
-/**
- * Finds any shortest path.
- * 
- * @param graph 
- * @param s 
- * @param d 
- */
-function findShortestPath(
-        graph: { [index:string]: { [index:string]: number } },
-        s: string,
-        d: string) {
-
-    const predecessors = singleSourceShortestPaths(graph, s, d);//?
-
-    return extractShortestPathFromPredecessorList(
-        predecessors, d
-    );
-}
-
-
-function findPathLength<T>(
-        graph: { [index:string]: { [index:string]: number } },
-        path: string[]) {
-
-    if (path.length === 0) { return 0; }
-
-    let d = 0;
-    let prevNode = path[0];
-    for (let i=1; i<path.length; i++) {
-        const S = prevNode;
-        const E = path[i];
-
-        d += S === E ? 0 : graph[S][E];
-
-        prevNode = E;
-    }
-
-    return d;
-}
-
-
-///////////////////////////
-// TESTING
-///////////////////////////
-
-function areStrArrsEql(
-        a: string[],
-        b: string[]) {
-
-    if (a.length !== b.length) { return false; }
-
-    for (let i=0; i<a.length; i++) {
-        if (a[i] !== b[i]) { return false; }
-    }
-
-    return true;
-}
-
-
-function areStrObjsEql(
-        a: { [index:string]: string },
-        b: { [index:string]: string }) {
-
-    const aKeys = Object.keys(a);
-    const bKeys = Object.keys(b);
-    if (!areStrArrsEql(aKeys, bKeys)) { return false; }
-
-    for (let i=0; i<aKeys.length; i++) {
-        const key = aKeys[i];
-        if (a[key] !== b[key]) { return false; }
-    }
-
-    return true;
-}
-
-
-{
-    // should find the path between two points, all edges have weight 1
-    const graph = {
-        a: {b: 10, d: 1},
-        b: {a: 1, c: 1, e: 1},
-        c: {b: 1, f: 1},
-        d: {a: 1, e: 1, g: 1},
-        e: {b: 1, d: 1, f: 1, h: 1},
-        f: {c: 1, e: 1, i: 1},
-        g: {d: 1, h: 1},
-        h: {e: 1, g: 1, i: 1},
-        i: {f: 1, h: 1}
-    };
-
-    findPathLength(graph, ['a', 'b', 'a', 'd', 'e', 'e', 'f', 'i']);//?
-    findPathLength(graph, ['a', 'd', 'e', 'f', 'i']);//?
-    findPathLength(graph, ['a', 'd', 'g', 'h', 'i']);//?
-    const path = findShortestPath(graph, 'a', 'i');//?
-    if (!(
-        areStrArrsEql(path, ['a', 'd', 'e', 'f', 'i']) ||
-        areStrArrsEql(path, ['a', 'd', 'g', 'h', 'i']))) {
-
-        throw new Error('Error')
-    }
-}
-
-/*
-{
-    // should find the path between two points, weighted edges
-    const graph = {
-        a: {b: 10, c: 100, d: 1},
-        b: {c: 10},
-        d: {b: 1, e: 1},
-        e: {f: 1},
-        f: {c: 1},
-        g: {b: 1}
-    };
-
-    let path = findShortestPath(graph, 'a', 'c');
-    if (!areStrArrsEql(path, ['a', 'd', 'e', 'f', 'c'])) {
-        throw new Error('Error')
-    }
-    path = findShortestPath(graph, 'd', 'b');
-    if (!areStrArrsEql(path, ['d', 'b'])) {
-        throw new Error('Error')
-    }
-}
-
-
-{
-    // should throw on unreachable destination
-    const graph = {
-        a: {b: 10, c: 100, d: 1},
-        b: {c: 10},
-        d: {b: 1, e: 1},
-        e: {f: 1},
-        f: {c: 1},
-        g: {b: 1}
-    };
-
-    // Exception 
-    let errored = false;
-    try { findShortestPath(graph, 'c', 'a'); } catch (e) { errored = true; }
-    if (!errored) {
-        throw new Error('Error');
-    }
-    // Exception 
-    errored = false;
-    try { findShortestPath(graph, 'a', 'g'); } catch (e) { errored = true; }
-    if (!errored) {
-        throw new Error('Error');
-    }
-}
-
-
-{
-    // should throw on non-existent destination
-    const graph = {
-        a: {b: 10, c: 100, d: 1},
-        b: {c: 10},
-        d: {b: 1, e: 1},
-        e: {f: 1},
-        f: {c: 1},
-        g: {b: 1}
-    };
-
-    // Exception 
-    let errored = false;
-    try { findShortestPath(graph, 'a', 'z'); } catch (e) { errored = true; }
-    if (!errored) {
-        throw new Error('Error');
-    }
-}
-
-
-{
-    // should find all paths from a node
-    const graph = {
-        a: {b: 10, c: 100, d: 1},
-        b: {c: 10},
-        d: {b: 1, e: 1},
-        e: {f: 1},
-        f: {c: 1},
-        g: {b: 1}
-    };
-
-    // All paths from 'a'
-    const paths = singleSourceShortestPaths(graph, 'a');//?
-    if (!areStrObjsEql(paths, ({ b: 'd', c: 'f', d: 'a', e: 'd', f: 'e' }))) {
-        throw new Error('Error')
-    }
-}
-*/

package/src/find-2-prong/find-and-add-2-prongs-on-all-paths.ts

@@ -1,38 +0,0 @@
-import { LlRbTree } from 'flo-ll-rb-tree';
-import { Loop } from 'flo-boolean';
-import { CpNode } from '../cp-node/cp-node.js';
-import { PointOnShape } from '../point-on-shape/point-on-shape.js';
-import { findAndAdd2Prongs } from './find-and-add-2-prongs.js';
-import { fixOrdering } from '../find-mat/fix-ordering.js';
-
-
-/** 
- * @internal
- * Add 2 prongs. See comments on the add2Prong function.
- * @param loops
- * @param cpGraphs
- * @param for2Prongss
- * @param extreme The maximum coordinate value used to calculate floating point
- * tolerances.
- */ 
-function findAndAdd2ProngsOnAllPaths(
-        cpNode: CpNode | undefined,
-        loops: Loop[],
-        cpGraphs: Map<Loop,LlRbTree<CpNode>>,
-        for2Prongss: PointOnShape[][],
-        extreme: number,
-        for1Prongs: boolean) {
-
-    for (let k=0; k<for2Prongss.length; k++) {
-        const for2Prongs = for2Prongss[k];
-        const _cpNode = findAndAdd2Prongs(loops, cpGraphs, k, for2Prongs, extreme, for1Prongs);
-        cpNode = cpNode || _cpNode;
-    }
-
-    fixOrdering(cpNode!);
-
-    return cpNode;
-}
-
-
-export { findAndAdd2ProngsOnAllPaths }

package/src/find-2-prong/find-equidistant-point-on-line-dd.ts

@@ -1,77 +0,0 @@
-import {
-    twoDiff, twoSum, twoProduct, doubleDivDouble, ddDivDd,
-    ddAddDd, ddDiffDd, ddMultDd, ddMultBy2, ddMultDouble1
-} from "double-double";
-
-
-const { abs } = Math;
-
-const td = twoDiff;
-const tp = twoProduct;
-
-
-
-/**
- * Returns the point on the line from y to x that is equidistant from y and z.
- * 
- * @internal
- * @param x
- * @param y
- * @param z
-  */
-function findEquidistantPointOnLineDd(
-        x: number[],
-        y: number[],
-        z: number[]) {
-    // Some basic algebra (not shown) finds the required point.
-    
-    // Swap axes if x and y are more aligned to y-axis than to x-axis.
-    const swapAxes = abs(x[1] - y[1]) > abs(x[0] - y[0]);
-    
-    // Cache
-    let x1: number;
-    let x2: number;
-    let y1: number;
-    let y2: number;
-    let z1: number;
-    let z2: number;
-    
-    if (swapAxes) {
-        x1 = x[1];    x2 = x[0];
-        y1 = y[1];    y2 = y[0];
-        z1 = z[1];    z2 = z[0];    
-    } else {
-        x1 = x[0];    x2 = x[1];
-        y1 = y[0];    y2 = y[1];
-        z1 = z[0];    z2 = z[1];
-    }
-    
-    // a <= 1 (due to swapped axes)
-    // const a = (x2 - y2) / (x1 - y1); 
-    // const b = y2 - a*y1;
-    // const c = (y1*y1 + y2*y2 - z1*z1 - z2*z2) + 2*b*(z2 - y2);
-    // const d = y1 - z1 + a*(y2 - z2);
-    // const t1 = c/(2*d);
-    // const t2 = a*t1 + b;
-
-    
-    const a = ddDivDd(td(x2,y2),td(x1,y1)); 
-    const b = ddDiffDd([0,y2], ddMultDouble1(y1,a));
-
-    const c = ddAddDd(
-        (ddDiffDd(
-            ddAddDd(tp(y1,y1), tp(y2,y2)),
-            ddAddDd(tp(z1,z1), tp(z2,z2))
-        )),
-        ddMultBy2(ddMultDd(b,(td(z2,y2))))
-    );
-
-    const d = ddAddDd(td(y1,z1), ddMultDd(a,td(y2,z2)));
-    const t1 = ddDivDd(c,ddMultBy2(d));
-    const t2 = ddAddDd(ddMultDd(a,t1), b);
-    
-    return swapAxes ? [t2[1],t1[1]] : [t1[1],t2[1]];
-}
-
-
-export { findEquidistantPointOnLineDd }

package/src/find-2-prong/find-equidistant-point-on-line.ts

@@ -1,40 +0,0 @@
-
-/**
- * @internal
- * @param x
- * @param y
- * @param z
- * @returns The point on the line from y to x that is equidistant from y and z. 
- */
-function findEquidistantPointOnLine(x: number[], y: number[], z: number[]) {
-    // Some basic algebra (not shown) finds the required point.
-    
-    // Swap axes if x and y are more aligned to y-axis than to x-axis.
-    const swapAxes = Math.abs((x[1] - y[1]) / (x[0] - y[0])) > 1;
-    
-    // Cache
-    let x1, x2, y1, y2, z1, z2;
-    
-    if (swapAxes) {
-        x1 = x[1];    x2 = x[0];
-        y1 = y[1];    y2 = y[0];
-        z1 = z[1];    z2 = z[0];    
-    } else {
-        x1 = x[0];    x2 = x[1];
-        y1 = y[0];    y2 = y[1];
-        z1 = z[0];    z2 = z[1];
-    }
-    
-    // a <= 1 (due to swapped axes)
-    const a = (x2 - y2) / (x1 - y1); 
-    const b = y2 - a*y1;
-    const c = (y1*y1 + y2*y2 - z1*z1 - z2*z2) + 2*b*(z2 - y2);
-    const d = y1 - z1 + a*(y2 - z2);
-    const t1 = c/(2*d);
-    const t2 = a*t1 + b;
-    
-    return swapAxes ? [t2,t1] : [t1,t2];
-}
-
-
-export { findEquidistantPointOnLine }

package/src/find-2-prong/pyth-trips.ts

@@ -1,146 +0,0 @@
-import { primitivePart } from "flo-poly";
-
-/**
- * From https://www.geeksforgeeks.org/generate-pythagorean-triplets/
- * 
- * Function to generate pythagorean triplets smaller than limit
- */
-function pythagoreanTriplets(
-        limit: number): number[][] {
-
-    // Triplet: a^2 + b^2 = c^2
-    let a = 0;
-    let b = 0;
-    let c = 0;
-
-    // Loop from 2 to max_limit
-    let m = 2;
-
-    const triples: number[][] = [];
-    // Limiting c would limit all a, b and c
-    while (c < limit) {
-        for(let n=1; n<m; ++n) {
-            a = m*m - n*n;
-            b = 2*m*n;
-            c = m*m + n*n;
-
-            if (c > limit) { break; }
-
-            triples.push([a,b,c]);
-        }
-        m++;
-    }
-
-    return triples;
-}
-
-
-function get1DegreeSpacingTriples() {
-    let limit = 10000;
-    const triplesRaw = pythagoreanTriplets(limit);
-    const triplesRed = triplesRaw.map(triple => {
-        let [x,y] = triple;
-        [x,y] = primitivePart([x,y]);
-        if (x > y) { [x,y] = [y,x]; }
-
-        return [x,y];
-    });
-
-    triplesRed.sort((a,b) => {
-        let res = a[0] - b[0];
-
-        if (res !== 0) { return res; }
-
-        return a[1] - b[1];
-    });
-
-    const triples: number[][] = [];
-    for (let i=0; i<triplesRed.length; i++) {
-        const tripleRedPrev = triplesRed[i-1];
-        const tripleRed = triplesRed[i];
-        if (tripleRedPrev === undefined ||
-            tripleRed[0] !== tripleRedPrev[0] ||
-            tripleRed[1] !== tripleRedPrev[1]) {
-
-            triples.push(tripleRed);
-        }
-    }
-
-
-    function toDeg(angle: number) {
-        return angle*180/Math.PI;
-    }
-
-    const triplesWithAngles = triples.map(triple => {
-        const [x,y] = triple;
-
-        return [x,y,toDeg(Math.atan2(y,x))];
-    }).sort((a,b) => a[2] - b[2]);//?
-
-    triplesWithAngles.length;//?
-    triplesWithAngles[0];//?
-    triplesWithAngles[triplesWithAngles.length-1];//?
-
-    const trips: number[][] = [];
-    const GAP = 1;
-    let prev = 45;
-    for (let t of triplesWithAngles) {
-        if (t[2] - prev > GAP) {
-            trips.push(t);
-            prev = t[2];
-        }
-    }
-
-    return trips;
-}
-
-
-// get1DegreeSpacingTriples();
-
-const triples = [
-    [ 2184, 2263, 46.017740165645755 ],
-    [ 2928, 3145, 47.046418040919235 ],
-    [ 2760, 3071, 48.0530131573584 ],
-    [ 1675, 1932, 49.075456953155594 ],
-    [ 3003, 3596, 50.13492687612096 ],
-    [ 3885, 4828, 51.177026282632845 ],
-    [ 1825, 2352, 52.19084831477669 ],
-    [ 3220, 4371, 53.621908600697374 ],
-    [ 3036, 4277, 54.63121594688451 ],
-    [ 935, 1368, 55.64819276850652 ],
-    [ 2813, 4284, 56.70992357064812 ],
-    [ 836, 1323, 57.71132243943304 ],
-    [ 175, 288, 58.715507085582544 ],
-    [ 1955, 3348, 59.718032329846196 ],
-    [ 276, 493, 60.75825202273669 ],
-    [ 8, 15, 61.92751306414704 ],
-    [ 1404, 2747, 62.92828726173151 ],
-    [ 39, 80, 64.01076641616699 ],
-    [ 2825, 6072, 65.04978057558209 ],
-    [ 1144, 2583, 66.11164562310735 ],
-    [ 5, 12, 67.38013505195958 ],
-    [ 168, 425, 68.4314042648748 ],
-    [ 1995, 5332, 69.48636031660722 ],
-    [ 1408, 3975, 70.49515011669244 ],
-    [ 301, 900, 71.5077745088735 ],
-    [ 1887, 6016, 72.5852594569592 ],
-    [ 7, 24, 73.73979529168804 ],
-    [ 2159, 7920, 74.75161499109633 ],
-    [ 1815, 7208, 75.86654056719784 ],
-    [ 1469, 6300, 76.87460298212505 ],
-    [ 924, 4307, 77.89161621177033 ],
-    [ 1008, 5135, 78.8940579339264 ],
-    [ 204, 1147, 79.91509786165818 ],
-    [ 315, 1972, 80.92445498418671 ],
-    [ 355, 2508, 81.94347266702972 ],
-    [ 520, 4209, 82.95709324615554 ],
-    [ 19, 180, 83.97442499163333 ],
-    [ 23, 264, 85.0208941560017 ],
-    [ 29, 420, 86.05013197823607 ],
-    [ 39, 760, 87.06239857122834 ],
-    [ 120, 3599, 88.09031749225564 ],
-    [ 127, 8064, 89.09772290642545 ]
-];
-
-
-export { triples }