flo-mat 4.0.3 → 4.1.0

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

@@ -2,7 +2,6 @@ import type { CpNode } from '../cp-node/cp-node.js';
 import type { ThreeProngInfo } from './three-prong-info.js';
 import { find3ProngForDelta3s } from './find-3-prong-for-delta3s.js';
 import { getBoundaryPieceBeziers } from '../mat/get-boundary-piece-beziers.js';
-import { timeFunctionCalls } from '../utils/time-function-call.js';
 
 
 /**

package/src/find-3-prong/find-and-add-3-prong.ts

@@ -25,21 +25,7 @@ function findAndAdd3Prong(
         δs.push([visitedCp, visitedCp.next]);
     }
 
-    // TODO - remove - debugging
-    //-------------------------
-    // ii++;
-    // if (ii === 13) {
-    //     //@ts-ignore
-    //     if (_debug_.temp === undefined) { _debug_.temp = []; }
-    //     //@ts-ignore
-    //     _debug_.temp.push(δs);
-    // }
-    // //@ts-ignore
-    // if (_debug_.temp2 === undefined) { _debug_.temp2 = []; }
-    // //@ts-ignore
-    // _debug_.temp2.push(δs.length);
-    //-------------------------
-    
+
     const threeProngInfo = find3Prong(δs, meta.maxCoordPowerOf2);
 
     const { circle, poss, δ3s } = threeProngInfo;

package/src/find-mat/find-mat.ts

@@ -8,7 +8,7 @@ import type { MatOptions } from './mat-options.js';
 import type { MatMeta } from '../mat/mat-meta.js';
 import { findAndAdd3ProngsOnLoop } from '../find-3-prong/find-and-add-3-prongs-on-loop.js';
 import { createInitialCpTree } from './create-initial-cp-tree.js';
-import { getPartialMeta, addDebugInfo2, addDebugInfo3, addDebugInfo4 } from './get-meta.js';
+import { getPartialMeta, addDebugInfo1, addDebugInfo2, addDebugInfo3, addDebugInfo4 } from './get-meta.js';
 import { getSharpCornersOnLoop } from './get-sharp-corners.js';
 import { getDullCornersOnLoop } from './get-dull-corners-on-loop.js';
 import { findAndAdd2ProngsOnAllLoops } from '../find-2-prong/find-and-add-2-prongs-on-all-loops.js';
@@ -32,6 +32,8 @@ function findMat(
             meta: MatMeta;
         } {
 
+    addDebugInfo1();
+
     const { minBezLength, maxCurviness, maxLength, angleIncrement } = options;
 
     const getSharpCornersOnLoop_ = getSharpCornersOnLoop(minBezLength);

package/src/find-mat/find-mats.ts

@@ -6,7 +6,6 @@ import { toScaleAxis } from '../sat/to-scale-axis.js';
 import { clipOptions } from './clip-options.js';
 import { findMat  } from './find-mat.js';
 import { defaultMatOptions, MatOptions } from './mat-options.js';
-import { circumCenter } from '../find-3-prong/timed-cc.js';
 
 
 const { ceil, log2 } = Math;

package/src/find-mat/get-dull-corners-on-loop.ts

@@ -19,12 +19,13 @@ function getDullCornersOnLoop(
             }
 
             const { next, ps } = curve;
-            
+
             if (getCorner(ps, next.ps).isQuiteDull) {
                 const p = ps[ps.length - 1];
+                const pDd = [[0,p[0]], [0,p[1]]];
 
-                dullCorners.push({ curve, t: 1, isSource: true, p });
-                dullCorners.push({ curve: next, t: 0, isSource: true, p });
+                dullCorners.push({ curve, t: 1, isSource: true, p, pDd });
+                dullCorners.push({ curve: next, t: 0, isSource: true, p, pDd });
             }
         }
 

package/src/find-mat/get-for-1-prongs-on-loop.ts

@@ -24,9 +24,14 @@ function getFor1ProngsOnLoop(
                 continue;
             }
 
-            poss.push(...getCurvatureExtremaDd(curve.ps).maxima.map(t => ({
-                curve, t, isSource: true, p: toP(curve.ps, t)
-            })));
+            const { ps } = curve;
+
+            poss.push(...getCurvatureExtremaDd(ps).maxima.map(t => {
+                const pDd = toP(ps, t);
+                const p = pDd.map(c => c[0] + c[1]);
+
+                return { curve, t, isSource: true, p, pDd }
+            }));
         }
 
         return poss;

package/src/find-mat/get-for-2-prongs-on-loop.ts

@@ -36,7 +36,12 @@ function getFor2ProngsOnLoop(
             ts = ts.filter(t => t !== 0 && t !== 1);
 
             const byCurvatureAndLength: PrePointOnShape[] = 
-                ts.map(t => ({ curve, t, isSource: true, p: toP(curve.ps, t) }));
+                ts.map(t => {
+                    const pDd = toP(curve.ps, t);
+                    const p = pDd.map(c => c[0] + c[1]);
+
+                    return { curve, t, isSource: true, p, pDd };
+                });
 
             for2Prongs.push(...byCurvatureAndLength);
         }

package/src/find-mat/get-meta.ts

@@ -64,6 +64,14 @@ function getPartialMeta(
 }
 
 
+function addDebugInfo1() {
+    if (typeof _debug_ === 'undefined') { return; }
+
+    timingStart = performance.now();
+}
+
+
+
 /** @internal */
 function addDebugInfo2() {
     if (typeof _debug_ === 'undefined') { return; }
@@ -74,6 +82,7 @@ function addDebugInfo2() {
 }
 
 
+/** @internal */
 function addDebugInfo3() {
     if (typeof _debug_ === 'undefined') { return; }
 
@@ -84,6 +93,7 @@ function addDebugInfo3() {
 }
 
 
+/** @internal */
 function addDebugInfo4() {
     if (typeof _debug_ === 'undefined') { return; }
 
@@ -93,6 +103,7 @@ function addDebugInfo4() {
 
 export {
     getPartialMeta,
+    addDebugInfo1,
     addDebugInfo2,
     addDebugInfo3,
     addDebugInfo4

package/src/find-mat/get-sharp-corners.ts

@@ -20,7 +20,11 @@ function getSharpCornersOnLoop(
             }
             
             if (getCorner(curve.ps, curve.next.ps).isQuiteSharp) {
-                sharpCorners.push({ curve, t: 1, isSource: true, p: toP(curve.ps, 1) });
+                const { ps } = curve;
+
+                const p = ps[ps.length - 1];
+                const pDd = [[0,p[0]],[0,p[1]]];
+                sharpCorners.push({ curve, t: 1, isSource: true, p, pDd });
             }
         }
 

package/src/get-medial-curve/get-cubic-self-medial-curve.py

@@ -0,0 +1,419 @@
+"""
+Pure symbolic setup for the cubic planar parametric self-medial problem.
+
+This file intentionally performs no numeric calculations.
+It derives polynomial equations in symbolic parameters only.
+
+Core idea (self-contact pair on one cubic r(u) = (X(u), Y(u))):
+1. Use two parameters t and s on the same cubic, and an unknown medial point m.
+2. Use two separate spoke vectors:
+    v_t = r(t) - m
+    v_s = r(s) - m
+3. Enforce orthogonality at both contacts:
+    v_t . r'(t) = 0
+    v_s . r'(s) = 0
+4. Enforce equal spoke lengths (equal-radius condition):
+    |v_t|^2 - |v_s|^2 = 0
+5. Remove the trivial branch t = s.
+
+These polynomial constraints define the nontrivial self-medial relation.
+"""
+
+from __future__ import annotations
+
+from sympy import Matrix, Poly, expand, fraction, simplify, symbols
+
+
+SymPoint = Matrix
+
+
+def cubic_power_point_sym(cx, cy, u):
+    """
+    Return the symbolic point r(u) = (X(u), Y(u)) in power basis.
+
+    Parameters:
+    - cx: coefficients [x0, x1, x2, x3] for X(u)=x0+x1*u+x2*u^2+x3*u^3.
+    - cy: coefficients [y0, y1, y2, y3] for Y(u)=y0+y1*u+y2*u^2+y3*u^3.
+    - u: symbolic parameter.
+
+    Returns:
+    - A 2D SymPy column vector representing r(u).
+    """
+    x0, x1, x2, x3 = cx
+    y0, y1, y2, y3 = cy
+    xu = x0 + x1*u + x2*(u**2) + x3*(u**3)
+    yu = y0 + y1*u + y2*(u**2) + y3*(u**3)
+    return Matrix([xu, yu])
+
+
+def cubic_power_d1_sym(cx, cy, u):
+    """
+    Return the symbolic first derivative r'(u) in power basis.
+
+    Parameters:
+    - cx: coefficients [x0, x1, x2, x3] of X(u).
+    - cy: coefficients [y0, y1, y2, y3] of Y(u).
+    - u: symbolic parameter.
+
+    Returns:
+    - A 2D SymPy column vector representing r'(u).
+    """
+    _, x1, x2, x3 = cx
+    _, y1, y2, y3 = cy
+    dx = x1 + 2*x2*u + 3*x3*(u**2)
+    dy = y1 + 2*y2*u + 3*y3*(u**2)
+    return Matrix([dx, dy])
+
+
+def dot2(a: SymPoint, b: SymPoint):
+    return a[0]*b[0] + a[1]*b[1]
+
+
+def orthogonality_equations(cx, cy, t, s, m: SymPoint):
+    """
+    Build the two orthogonality equations for a self-contact pair.
+
+    Equations:
+    - (r(t) - m) . r'(t) = 0
+    - (r(s) - m) . r'(s) = 0
+    """
+    rt = cubic_power_point_sym(cx, cy, t)
+    rs = cubic_power_point_sym(cx, cy, s)
+    d1t = cubic_power_d1_sym(cx, cy, t)
+    d1s = cubic_power_d1_sym(cx, cy, s)
+
+    vt = rt - m
+    vs = rs - m
+
+    e_ortho_t = simplify(dot2(vt, d1t))
+    e_ortho_s = simplify(dot2(vs, d1s))
+
+    return e_ortho_t, e_ortho_s
+
+
+def equal_length_equation(cx, cy, t, s, m: SymPoint):
+    """
+    Build the equal-length spoke equation for a self-contact pair.
+
+    Equation:
+    - |r(t) - m|^2 - |r(s) - m|^2 = 0
+    """
+    rt = cubic_power_point_sym(cx, cy, t)
+    rs = cubic_power_point_sym(cx, cy, s)
+
+    vt = rt - m
+    vs = rs - m
+
+    return simplify(dot2(vt, vt) - dot2(vs, vs))
+
+
+def self_medial_equation_system(cx, cy, t, s, m: SymPoint):
+    """
+    Return the core symbolic self-medial system {E_t, E_s, E_l}.
+
+    Where:
+    - E_t := (r(t) - m) . r'(t)
+    - E_s := (r(s) - m) . r'(s)
+    - E_l := |r(t) - m|^2 - |r(s) - m|^2
+    """
+    e_t, e_s = orthogonality_equations(cx, cy, t, s, m)
+    e_l = equal_length_equation(cx, cy, t, s, m)
+    return {
+        "E_t": simplify(e_t),
+        "E_s": simplify(e_s),
+        "E_l": simplify(e_l),
+    }
+
+
+def _linear_coeffs_in_m(expr, mx, my):
+    """Return coefficients (a, b, c) for a*mx + b*my + c from expr."""
+    p = Poly(expr, mx, my)
+    a = p.coeff_monomial(mx)
+    b = p.coeff_monomial(my)
+    c = p.coeff_monomial(1)
+    return a, b, c
+
+
+def eliminate_medial_point(system, mx, my):
+    """
+    First elimination step: remove mx,my from {E_t,E_s,E_l}.
+
+    Strategy:
+    - E_t and E_s are linear in mx,my.
+    - Solve E_t=0 and E_s=0 symbolically for mx,my via Cramer's rule.
+    - Substitute into E_l to get a reduced relation in t,s and curve coefficients.
+
+    Returns:
+    - det_m: determinant of the 2x2 linear system in (mx,my)
+    - mx_expr, my_expr: symbolic solutions for mx,my
+    - E_l_reduced: E_l after substitution
+    """
+    e_t = system["E_t"]
+    e_s = system["E_s"]
+    e_l = system["E_l"]
+
+    a_t, b_t, c_t = _linear_coeffs_in_m(e_t, mx, my)
+    a_s, b_s, c_s = _linear_coeffs_in_m(e_s, mx, my)
+
+    det_m = a_t*b_s - a_s*b_t
+
+    mx_expr = (b_t*c_s - b_s*c_t) / det_m
+    my_expr = (a_s*c_t - a_t*c_s) / det_m
+
+    e_l_reduced = e_l.subs({mx: mx_expr, my: my_expr})
+
+    return {
+        "det_m": simplify(det_m),
+        "mx_expr": simplify(mx_expr),
+        "my_expr": simplify(my_expr),
+        "E_l_reduced": simplify(e_l_reduced),
+    }
+
+
+def reduced_ts_polynomial_data(elim1, t, s):
+    """
+    Summarize the reduced t,s relation after eliminating mx,my.
+
+    Returns:
+    - N_ts: denominator-cleared numerator of E_l_reduced
+    - deg_t_N, deg_s_N: polynomial degrees of N_ts in t and s
+    - generic_branch_condition: det_m != 0
+    """
+    n_ts, d_ts = fraction(simplify(elim1["E_l_reduced"]))
+    n_ts = simplify(n_ts)
+
+    return {
+        "N_ts": n_ts,
+        "D_ts": simplify(d_ts),
+        "deg_t_N": poly_degree(n_ts, t),
+        "deg_s_N": poly_degree(n_ts, s),
+        "generic_branch_condition": simplify(elim1["det_m"]),
+    }
+
+
+def extract_t_minus_s_factor(n_ts, t, s):
+    """
+    Step 5.5: expand N(t,s) and deflate any (t-s)^k factor.
+
+    Returns:
+    - N_expanded: expanded polynomial expression
+    - ts_multiplicity: largest k with (t-s)^k dividing N
+    - N_deflated: N / (t-s)^k
+    - deg_t_deflated, deg_s_deflated
+    """
+    n_expanded = expand(simplify(n_ts))
+
+    p = Poly(n_expanded, t, s)
+    ts = Poly(t - s, t, s)
+
+    q = p
+    multiplicity = 0
+    while True:
+        qq, rr = q.div(ts)
+        if rr.is_zero:
+            q = qq
+            multiplicity += 1
+        else:
+            break
+
+    n_deflated = simplify(q.as_expr())
+
+    return {
+        "N_expanded": n_expanded,
+        "ts_multiplicity": multiplicity,
+        "N_deflated": n_deflated,
+        "deg_t_deflated": q.degree(t),
+        "deg_s_deflated": q.degree(s),
+    }
+
+
+def get_degree5_ts_polynomial():
+    """
+    Build and return the deflated self-medial relation polynomial in (t,s).
+
+    For the generic cubic power basis setup in this file, the returned
+    polynomial is the Step-5 numerator with the trivial (t-s)^k factor removed.
+    In the current symbolic setup this yields a degree-5 in t and degree-5 in s
+    polynomial (generic branch).
+    """
+    x0, x1, x2, x3 = symbols("x0 x1 x2 x3", real=True)
+    y0, y1, y2, y3 = symbols("y0 y1 y2 y3", real=True)
+    t, s = symbols("t s", real=True)
+    mx, my = symbols("mx my", real=True)
+
+    cx = [x0, x1, x2, x3]
+    cy = [y0, y1, y2, y3]
+    m = Matrix([mx, my])
+
+    system = self_medial_equation_system(cx, cy, t, s, m)
+    elim1 = eliminate_medial_point(system, mx, my)
+    reduced = reduced_ts_polynomial_data(elim1, t, s)
+    ts_deflate = extract_t_minus_s_factor(reduced["N_ts"], t, s)
+
+    return {
+        "t": t,
+        "s": s,
+        "coeffs_x": (x0, x1, x2, x3),
+        "coeffs_y": (y0, y1, y2, y3),
+        "det_m": reduced["generic_branch_condition"],
+        "ts_multiplicity": ts_deflate["ts_multiplicity"],
+        "P5": ts_deflate["N_deflated"],
+        "deg_t": ts_deflate["deg_t_deflated"],
+        "deg_s": ts_deflate["deg_s_deflated"],
+    }
+
+
+def step7_symbolic_mapping_data():
+    """
+    Step 7 symbolic post-processing stub (no numerics).
+
+    This function packages the symbolic objects needed after obtaining P5:
+    1. Parameter-space relation: P5(t,s) = 0
+    2. Branch constraints:
+       - det_m(t,s) != 0
+       - t - s != 0 (nontrivial branch)
+    3. Reconstruction map from parameter pairs to medial points:
+       (t,s) -> (mx(t,s), my(t,s))
+
+    It does not solve P5 or evaluate any numeric roots.
+    """
+    x0, x1, x2, x3 = symbols("x0 x1 x2 x3", real=True)
+    y0, y1, y2, y3 = symbols("y0 y1 y2 y3", real=True)
+    t, s = symbols("t s", real=True)
+    mx, my = symbols("mx my", real=True)
+
+    cx = [x0, x1, x2, x3]
+    cy = [y0, y1, y2, y3]
+    m = Matrix([mx, my])
+
+    system = self_medial_equation_system(cx, cy, t, s, m)
+    elim1 = eliminate_medial_point(system, mx, my)
+    reduced = reduced_ts_polynomial_data(elim1, t, s)
+    ts_deflate = extract_t_minus_s_factor(reduced["N_ts"], t, s)
+
+    return {
+        "t": t,
+        "s": s,
+        "coeffs_x": (x0, x1, x2, x3),
+        "coeffs_y": (y0, y1, y2, y3),
+        "P5": ts_deflate["N_deflated"],
+        "deg_t_P5": ts_deflate["deg_t_deflated"],
+        "deg_s_P5": ts_deflate["deg_s_deflated"],
+        "trivial_factor_multiplicity": ts_deflate["ts_multiplicity"],
+        "constraint_det_nonzero": reduced["generic_branch_condition"],
+        "constraint_t_minus_s_nonzero": t - s,
+        "mx_of_ts": elim1["mx_expr"],
+        "my_of_ts": elim1["my_expr"],
+    }
+
+
+def normalize_reduced_numerator(n_ts, t, s):
+    """
+    Remove obvious repeated factors from N(t,s).
+
+    This keeps only the primitive square-free part in Q[coeffs][t,s].
+    """
+    p = Poly(simplify(n_ts), t, s)
+    content, primitive = p.primitive()
+    sqf = primitive.sqf_part()
+
+    return {
+        "content": simplify(content),
+        "N_primitive": simplify(primitive.as_expr()),
+        "N_sqf": simplify(sqf.as_expr()),
+        "deg_t_sqf": sqf.degree(t),
+        "deg_s_sqf": sqf.degree(s),
+        "repeated_factor_removed": sqf.total_degree() < primitive.total_degree(),
+    }
+
+
+def poly_degree(expr, var):
+    return Poly(simplify(expr), var).degree()
+
+
+
+def _demo_symbolic(*, run_step6: bool = False) -> None:
+    # Generic cubic power basis:
+    # X(u)=x0+x1*u+x2*u^2+x3*u^3, Y(u)=y0+y1*u+y2*u^2+y3*u^3
+    x0, x1, x2, x3 = symbols("x0 x1 x2 x3", real=True)
+    y0, y1, y2, y3 = symbols("y0 y1 y2 y3", real=True)
+    t, s = symbols("t s", real=True)
+    mx, my = symbols("mx my", real=True)
+
+    cx = [x0, x1, x2, x3]
+    cy = [y0, y1, y2, y3]
+
+    m = Matrix([mx, my])
+    e_ortho_t, e_ortho_s = orthogonality_equations(cx, cy, t, s, m)
+    e_equal = equal_length_equation(cx, cy, t, s, m)
+    system = self_medial_equation_system(cx, cy, t, s, m)
+    elim1 = eliminate_medial_point(system, mx, my)
+    reduced = reduced_ts_polynomial_data(elim1, t, s)
+    ts_deflate = extract_t_minus_s_factor(reduced["N_ts"], t, s)
+    degree5 = get_degree5_ts_polynomial()
+    normalized = None
+    if run_step6:
+        normalized = normalize_reduced_numerator(ts_deflate["N_deflated"], t, s)
+
+    print("Step 1: Orthogonality equations")
+    print("(r(t)-m) . r'(t) =", e_ortho_t)
+    print("(r(s)-m) . r'(s) =", e_ortho_s)
+    print()
+
+    print("Step 2: Equal-length equation")
+    print("|r(t)-m|^2 - |r(s)-m|^2 =", e_equal)
+    print()
+
+    print("Step 3: Packaged symbolic system {E_t, E_s, E_l}")
+    print("E_t =", system["E_t"])
+    print("E_s =", system["E_s"])
+    print("E_l =", system["E_l"])
+    print()
+
+    print("Step 4: First elimination (remove mx,my)")
+    print("det_m =", elim1["det_m"])
+    print("mx(t,s) =", elim1["mx_expr"])
+    print("my(t,s) =", elim1["my_expr"])
+    print("E_l after substitution =", elim1["E_l_reduced"])
+    print()
+
+    print("Step 5: Reduced single relation data")
+    print("N(t,s) (numerator after clearing denominator) =", reduced["N_ts"])
+    print("deg_t N =", reduced["deg_t_N"])
+    print("deg_s N =", reduced["deg_s_N"])
+    print("generic branch condition: det_m != 0, where det_m =", reduced["generic_branch_condition"])
+    print()
+
+    print("Step 5.5: (t-s) deflation")
+    print("(t-s) multiplicity in N =", ts_deflate["ts_multiplicity"])
+    print("deg_t N_deflated =", ts_deflate["deg_t_deflated"])
+    print("deg_s N_deflated =", ts_deflate["deg_s_deflated"])
+    print()
+
+    print("Final deflated polynomial for future work")
+    print("P5(t,s) =", degree5["P5"])
+    print()
+
+    print("Step 7: Symbolic mapping stub")
+    print("Use step7_symbolic_mapping_data() to get:")
+    print("- P5(t,s)=0 in parameter space")
+    print("- constraints det_m!=0 and t-s!=0")
+    print("- reconstruction map (t,s)->(mx(t,s), my(t,s))")
+
+    if run_step6:
+        print("Step 6: Normalized reduced numerator")
+        print("(applied to N_deflated)")
+        print("content(N) =", normalized["content"])
+        print("repeated factors removed =", normalized["repeated_factor_removed"])
+        print("deg_t N_sqf =", normalized["deg_t_sqf"])
+        print("deg_s N_sqf =", normalized["deg_s_sqf"])
+    else:
+        print("Step 6: Normalized reduced numerator")
+        print("Skipped by default (can be expensive on fully generic coefficients).")
+        print("To run it, call _demo_symbolic(run_step6=True).")
+
+    print()
+
+
+if __name__ == "__main__":
+    _demo_symbolic()

package/src/get-medial-points/double-double/dd-get-medial-point-coeffs-bez0-with-running-err.ts

@@ -0,0 +1,76 @@
+// import { ddAddDd, ddMultDd, ddMultBy2, ddDiffDouble } from 'double-double';
+
+// const { abs } = Math;
+
+// const qaq = ddAddDd;
+// const qmq = ddMultDd;
+// const qm2 = ddMultBy2;
+// const qdd = ddDiffDouble;
+
+
+// // TODO - move all these back to flo-bezier3
+// // TODO - finish
+
+// /**
+//  * Returns the coefficients `a0` and `b0` for the linear equation
+//  * `a0⋅t + b0 = 0`, so the ray parameter can be recovered as `t = -b0/a0`.
+//  * That parameter value makes `q(t) = p + t⋅v` equidistant from `p` and `P`.
+//  * 
+//  * Let `p` be a fixed point in the plane.\
+//  * Let `v` be a direction vector defining the ray `q(t) = p + t⋅v`.\
+//  * Let `P` be another point.\
+//  *
+//  * In other words, this function returns the coefficients needed to solve for
+//  * the ray parameter of the medial point on the ray.
+//  *
+//  * @param p base point
+//  * @param v ray direction from `p`
+//  * @param P another "target" point, e.g. `[1,2]`
+//  */
+// function ddGetMedialPointCoeffsBez0_WithRunningError(
+//         p: number[][],
+//         v: number[][],
+//         P: number[]) {
+
+//     // -----------------------------------------------------
+//     // See get-medial-points.md for implementation details.
+//     // -----------------------------------------------------
+//     // See error-bound-calc.txt
+//     // -----------------------------------------------------
+
+//     const [px, py] = p;
+//     const [vx, vy] = v;
+//     const [x0, y0] = P;
+
+//     // Constant bezier in power basis: b(s) = c
+//     // u(s) = p - b(s) = u0
+
+//     const $px = px[0] + px[1];
+//     const $py = py[0] + py[1];
+//     const $vx = vx[0] + vx[1];
+//     const $vy = vy[0] + vy[1];
+
+//     const $u0x = $px - x0;
+//     const _u0x = abs($u0x);
+//     // const u0x_ = px_
+
+//     const $u0y = $py - y0;
+//     const _u0y = abs($u0y);
+
+//     const u0x = qdd(px,x0);
+//     const u0y = qdd(py,y0);
+
+//     // E2(s,t): |t⋅v|² - |u(s) + t⋅v|² = 0
+//     //         => 2⋅(v⋅u(s))⋅t + |u(s)|² = 0
+//     //         => A(s)⋅t + B(s) = 0
+
+//     // const a0 = 2*(vx*u0x + vy*u0y);
+//     // const b0 = u0x*u0x + u0y*u0y;
+//     const a0 = qaq(qmq(qm2(vx),u0x),qmq(qm2(vy),u0y));
+//     const b0 = qaq(qmq(u0x,u0x), qmq(u0y,u0y));
+
+//     return { a0, b0 };
+// }
+
+
+// export { ddGetMedialPointCoeffsBez0_WithRunningError }