三角形退化成线段后，最近点查询不能继续除以面积

public readonly record struct Vec3(double X, double Y, double Z)
{
    public static Vec3 operator +(Vec3 a, Vec3 b) => new(a.X + b.X, a.Y + b.Y, a.Z + b.Z);
    public static Vec3 operator -(Vec3 a, Vec3 b) => new(a.X - b.X, a.Y - b.Y, a.Z - b.Z);
    public static Vec3 operator *(Vec3 a, double s) => new(a.X * s, a.Y * s, a.Z * s);
    public double LengthSquared => Dot(this, this);
    public bool IsFinite => double.IsFinite(X) && double.IsFinite(Y) && double.IsFinite(Z);
    public static double Dot(Vec3 a, Vec3 b) => a.X * b.X + a.Y * b.Y + a.Z * b.Z;
    public static Vec3 Cross(Vec3 a, Vec3 b) => new(
        a.Y * b.Z - a.Z * b.Y,
        a.Z * b.X - a.X * b.Z,
        a.X * b.Y - a.Y * b.X);
}

public readonly record struct ClosestResult(Vec3 Point, double DistanceSquared, string Region, string Strategy);

public static class TriangleClosest
{
    private const double RelativeAreaSquared = 1e-24;

    public static ClosestResult Find(Vec3 point, Vec3 a, Vec3 b, Vec3 c)
    {
        if (!point.IsFinite || !a.IsFinite || !b.IsFinite || !c.IsFinite)
            throw new ArgumentException("coordinates must be finite");

        Vec3 ab = b - a, ac = c - a, bc = c - b;
        double scaleSquared = Math.Max(ab.LengthSquared, Math.Max(ac.LengthSquared, bc.LengthSquared));
        double areaSquared = Vec3.Cross(ab, ac).LengthSquared;
        if (!double.IsFinite(scaleSquared) || !double.IsFinite(areaSquared))
            throw new ArgumentOutOfRangeException(nameof(a), "intermediate exceeds numeric range");
        if (scaleSquared == 0 || areaSquared <= RelativeAreaSquared * scaleSquared * scaleSquared)
            return FindOnEdges(point, a, b, c);

        Vec3 ap = point - a;
        double d1 = Vec3.Dot(ab, ap), d2 = Vec3.Dot(ac, ap);
        EnsureFinite(d1, d2);
        if (d1 <= 0 && d2 <= 0) return Result(point, a, "A", "triangle");

        Vec3 bp = point - b;
        double d3 = Vec3.Dot(ab, bp), d4 = Vec3.Dot(ac, bp);
        EnsureFinite(d3, d4);
        if (d3 >= 0 && d4 <= d3) return Result(point, b, "B", "triangle");

        double vc = d1 * d4 - d3 * d2;
        EnsureFinite(vc);
        if (vc <= 0 && d1 >= 0 && d3 <= 0)
            return Result(point, a + ab * (d1 / (d1 - d3)), "AB", "triangle");

        Vec3 cp = point - c;
        double d5 = Vec3.Dot(ab, cp), d6 = Vec3.Dot(ac, cp);
        EnsureFinite(d5, d6);
        if (d6 >= 0 && d5 <= d6) return Result(point, c, "C", "triangle");

        double vb = d5 * d2 - d1 * d6;
        EnsureFinite(vb);
        if (vb <= 0 && d2 >= 0 && d6 <= 0)
            return Result(point, a + ac * (d2 / (d2 - d6)), "CA", "triangle");

        double va = d3 * d6 - d5 * d4;
        EnsureFinite(va);
        if (va <= 0 && d4 - d3 >= 0 && d5 - d6 >= 0)
        {
            double w = (d4 - d3) / ((d4 - d3) + (d5 - d6));
            return Result(point, b + bc * w, "BC", "triangle");
        }

        double inverse = 1.0 / (va + vb + vc);
        double v = vb * inverse, wFace = vc * inverse;
        return Result(point, a + ab * v + ac * wFace, "face", "triangle");
    }

    private static ClosestResult FindOnEdges(Vec3 point, Vec3 a, Vec3 b, Vec3 c)
    {
        var candidates = new[]
        {
            Segment(point, a, b, "AB"), Segment(point, b, c, "BC"), Segment(point, c, a, "CA")
        };
        ClosestResult best = candidates[0];
        for (int i = 1; i < candidates.Length; i++)
            if (candidates[i].DistanceSquared < best.DistanceSquared) best = candidates[i];
        return best;
    }

    private static ClosestResult Segment(Vec3 point, Vec3 a, Vec3 b, string region)
    {
        Vec3 edge = b - a;
        double lengthSquared = edge.LengthSquared;
        double projection = Vec3.Dot(point - a, edge);
        EnsureFinite(lengthSquared, projection);
        double t = lengthSquared == 0 ? 0 : Math.Clamp(projection / lengthSquared, 0, 1);
        return Result(point, a + edge * t, region, "edge-fallback");
    }

    private static ClosestResult Result(Vec3 source, Vec3 closest, string region, string strategy)
    {
        double distanceSquared = (source - closest).LengthSquared;
        EnsureFinite(distanceSquared);
        return new(closest, distanceSquared, region, strategy);
    }

    private static void EnsureFinite(params double[] values)
    {
        if (values.Any(value => !double.IsFinite(value)))
            throw new ArgumentOutOfRangeException("intermediate exceeds numeric range");
    }
}

cd "$WORK_DIR"
dotnet build .tmp/daily-labs/2026-11-06-1930/TriangleClosestLab.csproj -c Release
dotnet run --project .tmp/daily-labs/2026-11-06-1930/TriangleClosestLab.csproj -c Release --no-build

build: exit=0, warnings=0, errors=0
run: exit=0, passed=21, failed=0, skipped=0
naive_collinear_finite=false
fixed_degenerate: Q=(3,0,0), distanceSquared=4, region=BC, strategy=edge-fallback
fixed_narrow: Q=(1,0,0), approximation_error=2e-14
random_cases=10000, face_cases=1537, boundary_cases=8463
max_error=2.5121479338940403e-15
elapsed_ms=47.1541