flo-mat 4.1.4 → 5.0.1

package/src/cp-node/fs/is-fully-terminating.ts

@@ -1,32 +1,16 @@
 import type { CpNode } from "../cp-node.js";
-import { getAllOnCircle } from "./get-all-on-circle.js";
+import { getRealProngCount } from "./get-real-prong-count.js";
 import { isTerminating } from "./is-terminating.js";
-import { isTrivial } from "./is-trivial.js";
 
 
 /**
- * Like isTerminating() but only returns true if all cpNodes on the circle
- * (except this.prevOnCircle) is terminating.
+ * Like `isTerminating` but only returns `true` if all `CpNode`s on the circle
+ * (except possibly the one leading back, i.e. `this.prevOnCircle`) are
+ * terminating - i.e. the `CpNode` is terminating and its vertex has at most
+ * one real prong.
  */
 function isFullyTerminating(cpNode: CpNode) {
-    // const otherOnCircle = getAllOnCircle(cpNode.prevOnCircle, true);
-
-    // return otherOnCircle.every(isTerminating);
-    if (!isTerminating(cpNode)) {
-        return false;
-    }
-
-    if (isTrivial(cpNode)) {
-        return true;
-    }
-
-    while (cpNode.prev === cpNode.prevOnCircle) {
-        cpNode = cpNode.prev;
-    }
-
-    const otherOnCircle = getAllOnCircle(cpNode.prevOnCircle, true);
-
-    return otherOnCircle.every(isTerminating);
+    return isTerminating(cpNode) && getRealProngCount(cpNode) <= 1;
 }
 
 

package/src/cp-node/fs/is-on-same-circle.ts

@@ -1,11 +1,13 @@
 import { CpNode } from "../cp-node.js";
-import { getAllOnCircle } from "./get-all-on-circle.js";
 
 
 /**
- * Returns true if the 2 given `CpNode`s are on the same maximal disk 
+ * Returns true if the 2 given `CpNode`s are on the same maximal disk
  * circle.
- * 
+ *
+ * * O(1): all `CpNode`s on the same on-circle ring share the same `Circle`
+ *   object, and no other ring does (see `PointOnShape.circle`)
+ *
  * @param cpNode1 A `CpNode`.
  * @param cpNode2 Another `CpNode`
  */
@@ -13,10 +15,7 @@ function isOnSameCircle(
         cpNode1: CpNode,
         cpNode2: CpNode) {
 
-    // const cpNodes = getAllOnCircle(cpNode1, true);
-    const cpNodes = getAllOnCircle(cpNode1);
-
-    return cpNodes.indexOf(cpNode2) >= 0;
+    return cpNode1.pointOnShape.circle === cpNode2.pointOnShape.circle;
 }
 
 

package/src/cp-node/fs/is-on-same-loop.ts

@@ -1,4 +1,4 @@
-import type { CpNode } from "flo-mat";
+import { CpNode } from "../cp-node.js";
 
 
 function isOnSameLoop(
@@ -12,4 +12,4 @@ function isOnSameLoop(
 }
 
 
-export { isOnSameLoop }
+export { isOnSameLoop }

package/src/cp-node/fs/is-special.ts

@@ -2,13 +2,18 @@ import type { CpNode } from "../cp-node.js";
 import { getRealProngCount } from "./get-real-prong-count.js";
 
 
-function isSpecial(
-        cpNode: CpNode) {
-
+/**
+ * Returns `true` if the given `CpNode` is on a 'special' MAT vertex, i.e. one
+ * that is not a plain 2-prong: a leaf, a 3-prong (or higher) or a hole-closer.
+ * 
+ * * these are the vertices that must be kept when simplifying the MAT and
+ *   the vertices of the MAT seen as a graph
+ */
+function isSpecial(cpNode: CpNode) {
     return (
-        (getRealProngCount(cpNode) !== 2) &&
-        !cpNode.isHoleClosing
-    )
+        getRealProngCount(cpNode) !== 2 ||
+        cpNode.isHoleClosing
+    );
 }
 
 

package/src/cp-node/fs/is-vertex.ts

@@ -1,4 +1,4 @@
-import { CpNode } from "../cp-node.js";
+import type { CpNode } from "../cp-node.js";
 import { getAllOnCircle } from "./get-all-on-circle.js";
 
 

package/src/cp-node/fs/traverse-edges.ts

@@ -4,10 +4,14 @@ import { getAllOnLoop } from './get-all-on-loop.js';
 
 
 /**
- * Traverses all edges (depth first) of the given MAT tree starting at the given 
- * vertex (represented by a `CpNode`).
- * @param cpNode Any `CpNode` representing the start vertex.
- * @param traverseEdgesCallback A callback function for each CpNode representing the vertex at the 
+ * Traverses all edges of the given MAT tree exactly once each, calling the
+ * callback for one of the two `CpNode`s representing each edge.
+ *
+ * * the edges are visited in boundary order starting from the given `CpNode`
+ *   (not depth first)
+ *
+ * @param cpNode Any `CpNode` on the MAT.
+ * @param traverseEdgesCallback A callback function for each CpNode representing the vertex at the
  * start of an edge.
  */
 function traverseEdges(

package/src/cp-node/stringification/from-stringifyable.ts

@@ -1,58 +1,75 @@
-import type { PointOnShape } from "../../point-on-shape/point-on-shape.js";
-import type { CpNode } from "../cp-node";
-import type { CpNodeStringifyable } from "./cp-node-stringifyable";
-import { EDGES } from "./cp-node-stringifyable";
-import { loopFromStringifyable } from './loop-from-stringifyable.js';
-
-
-function fromStringifyable(
-        cpNodesStringifyable: CpNodeStringifyable) {
-
-    const { cpNodes: _cpNodes, loops: _loops } = cpNodesStringifyable;
-    const loops = _loops.map(loopFromStringifyable);
-    const loopsByIdx = new Map(loops.map(loop => [loop.idx, loop]));
-
-    //--------------------------------------------------------------------------
-    // First pass: build all CpNode objects with proper `cp`.
-    // Edges still hold number ids at this point.
-    //--------------------------------------------------------------------------
-    const cpNodes: CpNode[] = _cpNodes.map(cpNode_ => {
-        const { id, pointOnShape, isHoleClosing, isIntersection } = cpNode_;
-        const { circle, order, order2 } = pointOnShape;
-        const { curveIdx, loopIdx, p, pDd, t, isSource } = pointOnShape;
-
-        const curve = loopsByIdx.get(loopIdx)!.curves[curveIdx];
-
-        const pointOnShape_: PointOnShape = {
-            circle,
-            curve, p, pDd, t, isSource,
-            order, order2
-        };
-
-        return {
-            ...cpNode_,
-            id, isHoleClosing, isIntersection,
-            pointOnShape: pointOnShape_
-        } as CpNode;
-    });
-
-    //--------------------------------------------------------------------------
-    // Second pass: replace number id edges with real CpNode references.
-    //--------------------------------------------------------------------------
-    const nodeMap = new Map<number, CpNode>(cpNodes.map(n => [n.id, n]));
-
-    for (const cpNode of cpNodes) {
-        for (const edge of EDGES) {
-            const id = cpNode[edge] as unknown as number | undefined;
-            if (id === undefined) { continue; }
-
-            // @ts-ignore
-            cpNode[edge] = nodeMap.get(id)!;
-        }
-    }
-
-    return cpNodes[0];
-}
-
-
-export { fromStringifyable }
+import type { PointOnShape } from "../../point-on-shape/point-on-shape.js";
+import type { CpNode } from "../cp-node.js";
+import type { CpNodeStringifyable } from "./cp-node-stringifyable.js";
+import type { Mutable } from "../../utils/mutable.js";
+import { EDGES } from "./cp-node-stringifyable.js";
+import { getAllOnCircle } from "../fs/get-all-on-circle.js";
+import { loopFromStringifyable } from './loop-from-stringifyable.js';
+
+
+function fromStringifyable(
+        cpNodesStringifyable: CpNodeStringifyable) {
+
+    const { cpNodes: _cpNodes, loops: _loops } = cpNodesStringifyable;
+    const loops = _loops.map(loopFromStringifyable);
+    const loopsByIdx = new Map(loops.map(loop => [loop.idx, loop]));
+
+    //--------------------------------------------------------------------------
+    // First pass: build all CpNode objects with proper `cp`.
+    // Edges still hold number ids at this point.
+    //--------------------------------------------------------------------------
+    const cpNodes: CpNode[] = _cpNodes.map(cpNode_ => {
+        const { id, pointOnShape, isHoleClosing, isIntersection } = cpNode_;
+        const { circle, order, order2 } = pointOnShape;
+        const { curveIdx, loopIdx, p, pDd, t, isSource } = pointOnShape;
+
+        const curve = loopsByIdx.get(loopIdx)!.curves[curveIdx];
+
+        const pointOnShape_: PointOnShape = {
+            circle,
+            curve, p, pDd, t, isSource,
+            order, order2
+        };
+
+        return {
+            ...cpNode_,
+            id, isHoleClosing, isIntersection,
+            pointOnShape: pointOnShape_
+        } as CpNode;
+    });
+
+    //--------------------------------------------------------------------------
+    // Second pass: replace number id edges with real CpNode references.
+    //--------------------------------------------------------------------------
+    const nodeMap = new Map<number, CpNode>(cpNodes.map(n => [n.id, n]));
+
+    for (const cpNode of cpNodes) {
+        for (const edge of EDGES) {
+            const id = cpNode[edge] as unknown as number | undefined;
+            if (id === undefined) { continue; }
+
+            // @ts-ignore
+            cpNode[edge] = nodeMap.get(id)!;
+        }
+    }
+
+    //--------------------------------------------------------------------------
+    // Third pass: one shared `Circle` object per on-circle ring, as when the
+    // MAT was built (the JSON gave every contact point its own copy).
+    //--------------------------------------------------------------------------
+    const done = new Set<CpNode>();
+    for (const cpNode of cpNodes) {
+        if (done.has(cpNode)) { continue; }
+
+        const { circle } = cpNode.pointOnShape;
+        for (const cp of getAllOnCircle(cpNode)) {
+            done.add(cp);
+            (cp.pointOnShape as Mutable<PointOnShape>).circle = circle;
+        }
+    }
+
+    return cpNodes[0];
+}
+
+
+export { fromStringifyable }

package/src/cp-node/stringification/to-stringifyable.ts

@@ -5,9 +5,9 @@ import { loopToStringifyable } from "./loop-to-stringifyable.js";
 
 
 /**
- * Returns a deep clone of this `CpNode`. Can be used to copy the MAT 
- * since cloning a single `CpNode` necessarily implies cloning all 
- * `CpNode`s on the same MAT tree.
+ * Returns a plain, acyclic representation of the entire MAT the given `CpNode`
+ * is part of (the `CpNode` edges replaced by ids and the boundary loops
+ * included) suitable for `JSON.stringify`; `fromStringifyable` reverses it.
  */
 function toStringifyable(
         cpNode: CpNode): CpNodeStringifyable {

package/src/debug/debug.ts

@@ -1,8 +1,10 @@
+import type { Curve } from 'flo-boolean';
+
 
 /** @internal */
 interface Debug {
     /** Generated by debug object for later inspection */
-    elems: {};
+    elems: Elems;
     timing: Timing;
 
     /**
@@ -14,6 +16,28 @@ interface Debug {
 }
 
 
+/**
+ * Elements generated during `findMats` for later inspection (only available
+ * if debug has been enabled via `enableDebugForMat(true)`).
+ *
+ * The arrays are reset at the start of each `findMats` call and accumulate
+ * over all MATs found in that call, one entry per boundary bezier curve in the
+ * order the curves are encountered.
+ */
+interface Elems {
+    /** The loose (axis-aligned) bounding box of each boundary bezier curve */
+    readonly looseBoundingBoxes: number[][][];
+    /** The tight (rotated) bounding box of each boundary bezier curve */
+    readonly tightBoundingBoxes: number[][][];
+    /** The bounding hull of each boundary bezier curve */
+    readonly boundingHulls: number[][][];
+    /** The curves whose end point forms a quite sharp corner with the next curve */
+    readonly sharpCorners: Curve[];
+    /** The curves whose end point forms a quite dull corner with the next curve */
+    readonly dullCorners: Curve[];
+}
+
+
 /** @internal */
 interface Timing {
     holeClosers: number;
@@ -35,18 +59,31 @@ interface Directives {
 }
 
 
+/** Returns a fresh (empty) set of debug `Elems`. */
+function createEmptyElems(): Elems {
+    return {
+        looseBoundingBoxes: [],
+        tightBoundingBoxes: [],
+        boundingHulls: [],
+        sharpCorners: [],
+        dullCorners: []
+    };
+}
+
+
 function enableDebugForMat(debugOn: boolean) {
     if (!debugOn) { 
-        (window as any)._debug_ = undefined; 
+        (globalThis as any)._debug_ = undefined; 
         return;
     }
 
-    let debug: Debug = (window as any)._debug_;
+    let debug: Debug = (globalThis as any)._debug_;
 
     debug = { 
         ...debug, 
         elems: { 
-            ...debug?.elems
+            ...debug?.elems,
+            ...createEmptyElems()
         },
         timing: {
             ...debug?.timing,
@@ -71,10 +108,9 @@ function enableDebugForMat(debugOn: boolean) {
         }
     };
 
-    (window as any)._debug_ = debug;
+    (globalThis as any)._debug_ = debug;
 }
 
 
-export type { Debug, Timing, Directives }
-export { enableDebugForMat }
-
+export type { Debug, Elems, Timing, Directives }
+export { enableDebugForMat, createEmptyElems }

package/src/find-2-prong/add-2-prong.ts

@@ -1,6 +1,6 @@
 import type { CpNode } from '../cp-node/cp-node.js';
 import type { Circle } from '../geometry/circle.js';
-import type { PointOnShape, PrePointOnShape } from '../point-on-shape/point-on-shape.js';
+import type { PrePointOnShape } from '../point-on-shape/point-on-shape.js';
 import type { MatMeta } from '../mat/mat-meta.js';
 import type { Mutable } from '../utils/mutable.js';
 import { calcPosOrder } from '../point-on-shape/calc-pos-order.js';
@@ -35,13 +35,6 @@ function add2Prong(
     const orderSource = calcPosOrder(circle.center, pposSource);
     const orderAntipode = calcPosOrder(circle.center, pposAntipode);
 
-    const posAntipode: PointOnShape = {
-        ...pposAntipode, circle, order: orderAntipode, order2: 0
-    };
-    const posSource: PointOnShape = {
-        ...pposSource, circle, order: orderSource, order2: 0
-    }
-
     // Make sure there isn't already a ContactPoint close by - it can cause
     // floating point stability issues.
     if (!!getCloseByCpIfExist(meta, pposSource, circle, orderSource, 0, 2)) {
@@ -55,7 +48,7 @@ function add2Prong(
         isHoleClosing, isHoleClosing, circle,
         [orderSource, orderAntipode],
         meta,
-        [posSource, posAntipode]
+        [pposSource, pposAntipode]
     );
 
     if (anyFailed) {
@@ -83,12 +76,17 @@ function closeHole(
 
     const [cpNodeSource, cpNodeAntipode] = cpNodes as Mutable<CpNode>[];
 
+    // The twins form their own on-circle ring (a separate MAT vertex - that
+    // is what cuts the hole), so they get their own (equal) `Circle` object:
+    // one `Circle` object per ring.
+    const twinCircle: Circle = { ...cpNodeSource.pointOnShape.circle };
+
     // Antipode - create and insert twin
     const posAntipode = cpNodeAntipode.pointOnShape;
     const cpNodeAntipodeTwin = insertCpNode(
         true, true, false,
         cpTrees.get(posAntipode.curve.loop)!,
-        { ...posAntipode, order2: +1 },
+        { ...posAntipode, circle: twinCircle, order2: +1 },
         cpNodeAntipode,
         undefined,  // unused
         meta.lastInsertId
@@ -101,7 +99,7 @@ function closeHole(
     const cpNodeSourceTwin = insertCpNode(
         true, true, false,
         cpTrees.get(posSource.curve.loop)!,
-        { ...posSource!, order2: -1 },
+        { ...posSource!, circle: twinCircle, order2: -1 },
         cpNodeSource.prev,
         undefined,  // unused
         meta.lastInsertId

package/src/find-2-prong/calc-seperation-tolerance.ts

@@ -1,127 +1,46 @@
-import { ddAddDd, twoProduct, ddDiffDd, ddDivDd, twoDiff, ddMultDouble1 } from 'double-double';
-
-const tp = twoProduct;
-const qaq = ddAddDd;
-const qdq = ddDiffDd;
-const qmd = ddMultDouble1;
-
-const { acos } = Math;
-
-
 /**
- * Calculates and returns an appropriate seperation tolerance between `CpNode`s.
- * 
- * @param R radius of the circle implied by the curvature at the boundary
+ * Returns the *squared* separation tolerance between the two contact points
+ * `y` (the source point) and `z` (the antipode) of a candidate 2-prong: if
+ * `|yz|²` is below it the antipode is indistinguishable (to within the error
+ * tolerance `δ`) from the circle merely grazing the boundary at `y` - the
+ * near-1-prong case - and the 2-prong should be rejected.
+ *
+ * Derivation: the MAT circle (radius `r`) is tangent to the boundary at `y`
+ * and so is the osculating circle there (radius `R`), both centers lying on
+ * the inward normal at `y`. Approximating the boundary near `y` by the
+ * osculating circle, the MAT circle enlarged by `δ` crosses it at the angle
+ * `θ` (at the MAT center, measured from `y`) given by the law of cosines:
+ *
+ *     cos θ = (r(R-r) - rδ - δ²/2) / ((R-r)(r+δ))
+ *
+ * Points of the MAT circle within that angle of `y` are within `δ` of the
+ * boundary. The chord `|yz|` subtending `θ` is `2r·sin(θ/2)`, and since
+ * `2sin²(θ/2) = 1 - cos θ = (Rδ + δ²/2) / ((R-r)(r+δ))` the squared chord is
+ *
+ *     |yz|² = r²(2Rδ + δ²) / ((R-r)(r+δ))
+ *
+ * which is what is returned - in closed form, without the cancellation that
+ * recovering a tiny `θ` from `cos θ` suffers from.
+ *
+ * @param R radius of the osculating circle of the boundary at `y`
  * @param r radius of the MAT circle
- * @param θ angle between point...
+ * @param δ the error tolerance on distances
+ *
+ * @internal
  */
-function calcSeperationTolerance(
+function calcSquaredSeperationTolerance(
         R: number,
         r: number,
-        δ: number) {
+        δ: number): number {
 
-    const a = r + δ;
-    if (a >= R) {
+    if (r + δ >= R) {
+        // The enlarged MAT circle is at least as large as the osculating
+        // circle: every point on it is within tolerance of the boundary.
         return Infinity;
     }
 
-    const R_r_ = twoDiff(R,r);
-    const A_  = qmd(r,R_r_);  
-    const N_ = qdq(qdq(A_, tp(r,δ)), tp(δ,δ/2));
-    const D_ = qaq(A_,qmd(δ,R_r_));
-
-    const R_r = R - r;
-    const A = r*R_r; 
-    const N = A - r*δ - (δ*δ)/2;
-    const D = A + R_r*δ;    
-    const cosC = N/D;    
-    const Q = ddDivDd(N_,D_)[1];
-    // const Q = N_[1]/D_[1];
-    const C = acos(cosC);
-    const CC = acos(Q)
-
-    const θ = CC;
-
-    // return r*θ;
-    return r*θ;
+    return r*r*(2*R*δ + δ*δ) / ((R - r)*(r + δ));
 }
 
 
-export { calcSeperationTolerance }
-
-
-// Quokka tests
-
-// /**
-//  * Calculates and returns an appropriate seperation tolerance between `CpNode`s.
-//  * 
-//  * @param R radius of the circle implied by the curvature at the boundary
-//  * @param r radius of the MAT circle
-//  * @param θ angle between point...
-//  */
-// function calcSeperationTolerance2(
-//         R: number,
-//         r: number,
-//         δ: number) {
-
-//     const a = r + δ;
-//     if (a >= R) {
-//         return Infinity;
-//     }
-
-//     const b = R - r;
-//     const c = R;    
-    
-//     const N = c*c - a*a - b*b;
-//     const N_ = qdq(qdq(tp(c,c), tp(a,a)), tp(b,b));
-//     const D = 2*a*b;          
-//     const D_ = tp(-2*a,b);
-//     const Q = ddDivDd(N_,D_)[1];
-//     const cosC = -N/D;
-//     const C = acos(cosC);
-//     const CC = acos(Q);
-
-//     const θ = π - CC;
-
-//     return θ;
-//     // return r*θ;  // approximate arc with line
-// }
-
-
-// function degToRad(degrees: number) {
-//     return degrees/360*2*Math.PI;
-// }
-// function radToDeg(rad: number) {
-//     return rad*360/2/Math.PI;
-// }
-
-
-// const R = 699;
-// const r = 698;
-// const δ = 1000*2**-46;
-// calcSeperationTolerance(R,r,δ); 
-// calcSeperationTolerance2(R,r,δ);
-// calcSeperationTolerance3(R,r,δ);
-
-// // * see https://en.wikipedia.org/wiki/Law_of_cosines, Version suited to small angles
-// function calcSeperationTolerance3(
-//         R: number,
-//         r: number,
-//         δ: number) {
-
-//     const a = r + δ;
-//     const c = R - r;
-//     const b = R;    
-    
-//     // c² = (a - b)² + 4ab*sin²(θ/2) OR
-//     // (c² - (a - b)²)/4ab = sin²(θ/2)
-//     const cc = c*c; 
-//     const abc = a*a + b*b - 2*a*b;
-//     const A = cc - abc;
-//     const B = sqrt(A/(4*a*b));
-
-//     const θ = 2*asin(B);
-
-//     return θ;
-//     // return r*θ;  // approximate arc with line
-// }
+export { calcSquaredSeperationTolerance }

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

@@ -6,10 +6,10 @@ import { getInitialCurvePieces } from './get-initial-bezier-pieces.js';
 import { getAntipodalPoints } from './get-medial/get-antipodal-points.js';
 import { reduceRadius } from './reduce-radius.js';
 import { squaredDistanceBetweenDd } from './squared-distance-between-dd.js';
-import { cullCurvePieces } from './cull-bezier-pieces.js';
+import { cullCurvePieces } from '../closest-boundary-point/cull-curve-pieces.js';
 import { add1Prong } from './add-1-prong.js';
 import { toP } from '../point-on-shape/to-p.js';
-import { calcSeperationTolerance } from './calc-seperation-tolerance.js';
+import { calcSquaredSeperationTolerance } from './calc-seperation-tolerance.js';
 import { getInitialX } from './get-initial-x.js';
 import { ddNormal } from 'flo-bezier3';
 import { rotate } from 'flo-vector2d';
@@ -85,26 +85,24 @@ function find2Prong(
         );
 
         // The lines below is an optimization.
-        const xy2 = reduceRadius(maxCoordPowerOf2, rO, curvePieces, y, nnorm);
+        const xy2 = reduceRadius(rO, curvePieces, y, nnorm);
         const xy = sqrt(xy2);
 
         const l = sqrt(nnorm[0]**2 + nnorm[1]**2);
         xO = [y[0] + nnorm[0]/l*xy, y[1] + nnorm[1]/l*xy];
 
-        cullCurvePieces(curvePieces, xO, xy2);
+        // (the extra multiplier accounts for floating point error)
+        const culledCurvePieces = cullCurvePieces(curvePieces, xO, (1 + 2**-20)*xy2);
 
         const antipodalPoints = getAntipodalPoints(
-            maxCoordPowerOf2, nnorm, nnormDd, yPos,
+            maxCoordPowerOf2, nnormDd, yPos,
             for1Prong, angle,
-            curvePieces
+            culledCurvePieces
         );
 
         // FUTURE - if antipodalPoints.length > 1 let's just add an n-prong;
         if (antipodalPoints.length !== 1) {
             if (antipodalPoints.length === 0) {
-                if (isHoleClosing) {
-                    console.log(yPos)
-                }
                 return undefined;
             }
             if (!isHoleClosing && !areAllAntipodesSame(antipodalPoints, maxCoordPowerOf2)) {
@@ -144,7 +142,7 @@ function find2Prong(
             // The lines below eliminate cases where the found 2-prong is too
             // close to a one-prong
             const squaredSeperationTolerance = max(
-                calcSeperationTolerance(rO, sqrt(xz), (2**2)*errorTolerance),
+                calcSquaredSeperationTolerance(rO, sqrt(xz), (2**2)*errorTolerance),
                 minSquaredSeperationTolerance
             );
             if (yz <= squaredSeperationTolerance) {
@@ -171,7 +169,7 @@ function areAllAntipodesSame(
         // }
 
         const { x: x_ } = point[i];
-        if (abs(x[0] - x_[0]) > tol || abs(x[0] - x_[0]) > tol) {
+        if (abs(x[0] - x_[0]) > tol || abs(x[1] - x_[1]) > tol) {
             return false;
         }
     }