< Summary

Information

Class:	FixedMathSharp.Geometry.WidePlanarProjection
Assembly:	FixedMathSharp
File(s):	File 1: /home/runner/work/FixedMathSharp/FixedMathSharp/src/FixedMathSharp/Geometry/Wide/Common/WidePlanarProjection.Cone.cs File 2: /home/runner/work/FixedMathSharp/FixedMathSharp/src/FixedMathSharp/Geometry/Wide/Common/WidePlanarProjection.cs File 3: /home/runner/work/FixedMathSharp/FixedMathSharp/src/FixedMathSharp/Geometry/Wide/Common/WidePlanarProjection.Disk.cs File 4: /home/runner/work/FixedMathSharp/FixedMathSharp/src/FixedMathSharp/Geometry/Wide/Common/WidePlanarProjection.Polygon.cs

Line coverage

100%

Covered lines:	2050
Uncovered lines:	0
Coverable lines:	2050
Total lines:	2939
Line coverage:	100%

Branch coverage

100%

Covered branches:	234
Total branches:	234
Branch coverage:	100%

Method coverage

Feature is only available for sponsors

Upgrade to PRO version

Metrics

Method	Branch coverage	Crap Score	Cyclomatic complexity	Line coverage
File 1: TryGetRotatedConeRelation(...)	100%	8	8	100%
File 1: GetProjectedConeCeilingDistance(...)	100%	16	16	100%
File 1: FindProjectedConeCeilingDistance(...)	100%	4	4	100%
File 1: GetProjectedConeClosestOffset(...)	100%	2	2	100%
File 1: GetSegmentOffset(...)	100%	1	1	100%
File 1: KeepCloserOffset(...)	100%	4	4	100%
File 1: CompareConeDistanceToRadius(...)	100%	8	8	100%
File 1: GetConeProjectionData(...)	100%	1	1	100%
File 1: IsPointInConeProjectionWedge(...)	100%	4	4	100%
File 1: TryCompareConeTangentDistanceToRadius(...)	100%	4	4	100%
File 1: CompareConeTangentSquaredDistance(...)	100%	6	6	100%
File 1: CompareRationalDistanceToRadius(...)	100%	2	2	100%
File 2: .ctor(...)	100%	1	1	100%
File 2: .ctor(...)	100%	1	1	100%
File 2: AreSegmentEndpointDistancesAtLeast(...)	100%	6	6	100%
File 2: GetRawPoint(...)	100%	1	1	100%
File 2: TryGetSphereRelation(...)	100%	4	4	100%
File 2: TryGetCenteredCapsuleRelation(...)	100%	1	1	100%
File 2: TryGetCenteredCylinderRelation(...)	100%	4	4	100%
File 2: TryGetCenteredConeRelation(...)	100%	6	6	100%
File 2: TryCreateRadiallyExpandedRelation(...)	100%	4	4	100%
File 2: GetRotatedLocalAxis(...)	100%	1	1	100%
File 2: GetLocalOffsetNumerator(...)	100%	1	1	100%
File 2: GetWorldPoint(...)	100%	1	1	100%
File 2: GetCenteredAxisEndpoints(...)	100%	1	1	100%
File 2: GetCenteredBasisAxisEndpoints(...)	100%	1	1	100%
File 2: TryGetRadialGap(...)	100%	8	8	100%
File 2: GetPointDistance(...)	100%	1	1	100%
File 2: GetSegmentDistance(...)	100%	1	1	100%
File 2: GetSegmentDistance(...)	100%	6	6	100%
File 2: IsWithinRadius(...)	100%	1	1	100%
File 2: TryGetDistance(...)	100%	8	8	100%
File 2: CompareDistanceToRaw(...)	100%	1	1	100%
File 2: CompareDistanceToRaw(...)	100%	1	1	100%
File 2: CompareDistanceToTwiceRaw(...)	100%	1	1	100%
File 2: CompareDistanceToTwiceRaw(...)	100%	1	1	100%
File 2: GetOffset(...)	100%	1	1	100%
File 2: GetHalfToEvenIncrement(...)	100%	1	1	100%
File 2: GetLargestPositiveMagnitude(...)	100%	10	10	100%
File 3: TryGetProjectedDiskRelation(...)	100%	14	14	100%
File 3: GetProjectedDiskCeilingDistance(...)	100%	16	16	100%
File 3: FindProjectedDiskCeilingDistance(...)	100%	4	4	100%
File 3: GetProjectedDiskClosestOffset(...)	100%	1	1	100%
File 3: GetEllipseClosestOffset(...)	100%	4	4	100%
File 3: GetEllipseConstraintCoordinate(...)	100%	1	1	100%
File 3: GetProjectedDiskSegmentEndpoints(...)	100%	1	1	100%
File 3: CompareProjectedDiskDistanceToRadius(...)	100%	14	14	100%
File 3: CountProjectedDiskCircleRoots(...)	100%	2	2	100%
File 3: CreateProjectedDiskCirclePolynomial(...)	100%	2	2	100%
File 3: GetProjectedDiskConicCoefficient(...)	100%	1	1	100%
File 3: GetProjectedDiskRadialCoefficient(...)	100%	1	1	100%
File 3: GetSquaredPolynomial(...)	100%	1	1	100%
File 3: MultiplyBySmall(...)	100%	10	10	100%
File 3: DoubleSigned832(...)	100%	1	1	100%
File 3: EvaluateProjectedDiskConic(...)	100%	1	1	100%
File 4: TryGetOrientedBoxRelation(...)	100%	6	6	100%
File 4: TryGetTriangleRelation(...)	100%	2	2	100%
File 4: TryGetConvexRelation(...)	100%	6	6	100%
File 4: TryCreateRelation(...)	100%	4	4	100%
File 4: ContainsPoint(...)	100%	10	10	100%
File 4: BuildConvexHull(...)	100%	12	12	100%
File 4: SortAndDeduplicate(...)	100%	10	10	100%
File 4: ComparePoint(...)	100%	2	2	100%
File 4: GetTurn(...)	100%	1	1	100%
File 4: Cross(...)	100%	1	1	100%
File 4: KeepCloser(...)	100%	2	2	100%
File 4: CompareDistances(...)	100%	1	1	100%

File(s)

/home/runner/work/FixedMathSharp/FixedMathSharp/src/FixedMathSharp/Geometry/Wide/Common/WidePlanarProjection.Cone.cs

#	Line	Line coverage
	`1`	`//=======================================================================`
	`2`	`// WidePlanarProjection.Cone.cs`
	`3`	`//=======================================================================`
	`4`	`// MIT License, Copyright (c) 2024-present David Oravsky (mrdav30)`
	`5`	`// See LICENSE file in the project root for full license information.`
	`6`	`//=======================================================================`
	`7`
	`8`	`using System;`
	`9`
	`10`	`namespace FixedMathSharp.Geometry;`
	`11`
	`12`	`/// <content>`
	`13`	`/// Exact projected-cone hull admission and tangent-segment reduction.`
	`14`	`/// </content>`
	`15`	`internal static partial class WidePlanarProjection`
	`16`	`{`
	`17`	`private const int ConeComparisonWordCount = 56;`
	`18`
	`19`	`private static bool TryGetRotatedConeRelation(`
	`20`	`Vector2d circleCenter,`
	`21`	`Fixed64 circleRadius,`
	`22`	`RationalPoint baseCenter,`
	`23`	`RationalPoint apex,`
	`24`	`Signed192 coordinateDenominator,`
	`25`	`Signed192 axisDenominator,`
	`26`	`Signed192 axisX,`
	`27`	`Signed192 axisY,`
	`28`	`Signed192 axisZ,`
	`29`	`Fixed64 coneHeight,`
	`30`	`Fixed64 coneRadius,`
	`31`	`out PlanarProjectionRelation relation)`
	`32`	`{`
12	`33`	`RationalDistance baseDistance = GetPointDistance(`
12	`34`	`circleCenter,`
12	`35`	`coordinateDenominator,`
12	`36`	`baseCenter);`
12	`37`	`RationalDistance apexDistance = GetPointDistance(`
12	`38`	`circleCenter,`
12	`39`	`coordinateDenominator,`
12	`40`	`apex);`
12	`41`	`GetConeProjectionData(`
12	`42`	`baseDistance,`
12	`43`	`coordinateDenominator,`
12	`44`	`axisDenominator,`
12	`45`	`axisX,`
12	`46`	`axisY,`
12	`47`	`axisZ,`
12	`48`	`coneHeight,`
12	`49`	`coneRadius,`
12	`50`	`out Signed320 planarAxisSquared,`
12	`51`	`out Signed320 axisSquared,`
12	`52`	`out Signed576 delta,`
12	`53`	`out Signed576 axisProjection,`
12	`54`	`out Signed576 perpendicularProjection,`
12	`55`	`out Signed576 apexProjectionGap);`
	`56`
12	`57`	`int maximumComparison = CompareConeDistanceToRadius(`
12	`58`	`baseDistance,`
12	`59`	`apexDistance,`
12	`60`	`coordinateDenominator,`
12	`61`	`axisDenominator,`
12	`62`	`axisX,`
12	`63`	`axisY,`
12	`64`	`axisZ,`
12	`65`	`coneHeight,`
12	`66`	`coneRadius,`
12	`67`	`planarAxisSquared,`
12	`68`	`axisSquared,`
12	`69`	`delta,`
12	`70`	`axisProjection,`
12	`71`	`perpendicularProjection,`
12	`72`	`apexProjectionGap,`
12	`73`	`Signed192.Raw(circleRadius),`
12	`74`	`radiusDenominator: 1);`
12	`75`	`if (maximumComparison > 0)`
	`76`	`{`
2	`77`	`relation = default;`
2	`78`	`return false;`
	`79`	`}`
	`80`
10	`81`	`int zeroComparison = CompareConeDistanceToRadius(`
10	`82`	`baseDistance,`
10	`83`	`apexDistance,`
10	`84`	`coordinateDenominator,`
10	`85`	`axisDenominator,`
10	`86`	`axisX,`
10	`87`	`axisY,`
10	`88`	`axisZ,`
10	`89`	`coneHeight,`
10	`90`	`coneRadius,`
10	`91`	`planarAxisSquared,`
10	`92`	`axisSquared,`
10	`93`	`delta,`
10	`94`	`axisProjection,`
10	`95`	`perpendicularProjection,`
10	`96`	`apexProjectionGap,`
10	`97`	`default,`
10	`98`	`radiusDenominator: 1);`
10	`99`	`if (zeroComparison <= 0)`
	`100`	`{`
2	`101`	`relation = PlanarProjectionRelation.Contained;`
2	`102`	`return true;`
	`103`	`}`
	`104`
8	`105`	`GetProjectedConeClosestOffset(`
8	`106`	`baseDistance,`
8	`107`	`apexDistance,`
8	`108`	`coordinateDenominator,`
8	`109`	`axisX,`
8	`110`	`axisY,`
8	`111`	`axisZ,`
8	`112`	`coneRadius,`
8	`113`	`out Fixed64 approximateDistance,`
8	`114`	`out Vector2d direction);`
8	`115`	`long low = GetProjectedConeCeilingDistance(`
8	`116`	`baseDistance,`
8	`117`	`apexDistance,`
8	`118`	`coordinateDenominator,`
8	`119`	`axisDenominator,`
8	`120`	`axisX,`
8	`121`	`axisY,`
8	`122`	`axisZ,`
8	`123`	`coneHeight,`
8	`124`	`coneRadius,`
8	`125`	`planarAxisSquared,`
8	`126`	`axisSquared,`
8	`127`	`delta,`
8	`128`	`axisProjection,`
8	`129`	`perpendicularProjection,`
8	`130`	`apexProjectionGap,`
8	`131`	`circleRadius,`
8	`132`	`approximateDistance);`
	`133`
8	`134`	`long floor = low - 1L;`
8	`135`	`Signed192 midpointNumerator = WideArithmetic.AddSigned192(`
8	`136`	`WideArithmetic.AddSigned192(`
8	`137`	`Signed192.Signed(floor),`
8	`138`	`Signed192.Signed(floor)),`
8	`139`	`Signed192.Signed(1L));`
8	`140`	`int midpointComparison = CompareConeDistanceToRadius(`
8	`141`	`baseDistance,`
8	`142`	`apexDistance,`
8	`143`	`coordinateDenominator,`
8	`144`	`axisDenominator,`
8	`145`	`axisX,`
8	`146`	`axisY,`
8	`147`	`axisZ,`
8	`148`	`coneHeight,`
8	`149`	`coneRadius,`
8	`150`	`planarAxisSquared,`
8	`151`	`axisSquared,`
8	`152`	`delta,`
8	`153`	`axisProjection,`
8	`154`	`perpendicularProjection,`
8	`155`	`apexProjectionGap,`
8	`156`	`midpointNumerator,`
8	`157`	`radiusDenominator: 2);`
8	`158`	`long rounded = midpointComparison < 0`
8	`159`	`? floor`
8	`160`	`: midpointComparison > 0`
8	`161`	`? low`
8	`162`	`: floor + (floor & 1L);`
8	`163`	`Fixed64 distance = Fixed64.FromRaw(rounded);`
8	`164`	`relation = new PlanarProjectionRelation(`
8	`165`	`distance,`
8	`166`	`direction * distance,`
8	`167`	`direction);`
8	`168`	`return true;`
	`169`	`}`
	`170`
	`171`	`private static long GetProjectedConeCeilingDistance(`
	`172`	`RationalDistance baseDistance,`
	`173`	`RationalDistance apexDistance,`
	`174`	`Signed192 coordinateDenominator,`
	`175`	`Signed192 axisDenominator,`
	`176`	`Signed192 axisX,`
	`177`	`Signed192 axisY,`
	`178`	`Signed192 axisZ,`
	`179`	`Fixed64 coneHeight,`
	`180`	`Fixed64 coneRadius,`
	`181`	`Signed320 planarAxisSquared,`
	`182`	`Signed320 axisSquared,`
	`183`	`Signed576 delta,`
	`184`	`Signed576 axisProjection,`
	`185`	`Signed576 perpendicularProjection,`
	`186`	`Signed576 apexProjectionGap,`
	`187`	`Fixed64 maximum,`
	`188`	`Fixed64 approximate)`
	`189`	`{`
8	`190`	`long candidate = approximate.m_rawValue;`
8	`191`	`if (candidate > maximum.m_rawValue)`
1	`192`	`candidate = maximum.m_rawValue;`
	`193`
8	`194`	`int comparison = CompareConeDistanceToRadius(`
8	`195`	`baseDistance,`
8	`196`	`apexDistance,`
8	`197`	`coordinateDenominator,`
8	`198`	`axisDenominator,`
8	`199`	`axisX,`
8	`200`	`axisY,`
8	`201`	`axisZ,`
8	`202`	`coneHeight,`
8	`203`	`coneRadius,`
8	`204`	`planarAxisSquared,`
8	`205`	`axisSquared,`
8	`206`	`delta,`
8	`207`	`axisProjection,`
8	`208`	`perpendicularProjection,`
8	`209`	`apexProjectionGap,`
8	`210`	`Signed192.Signed(candidate),`
8	`211`	`radiusDenominator: 1);`
8	`212`	`if (comparison <= 0)`
	`213`	`{`
3	`214`	`long high = candidate;`
3	`215`	`long step = 1L;`
14	`216`	`while (high > 1L)`
	`217`	`{`
13	`218`	`long probe = high > step ? high - step : 0L;`
13	`219`	`if (probe == 0L`
13	`220`	`\|\| CompareConeDistanceToRadius(`
13	`221`	`baseDistance,`
13	`222`	`apexDistance,`
13	`223`	`coordinateDenominator,`
13	`224`	`axisDenominator,`
13	`225`	`axisX,`
13	`226`	`axisY,`
13	`227`	`axisZ,`
13	`228`	`coneHeight,`
13	`229`	`coneRadius,`
13	`230`	`planarAxisSquared,`
13	`231`	`axisSquared,`
13	`232`	`delta,`
13	`233`	`axisProjection,`
13	`234`	`perpendicularProjection,`
13	`235`	`apexProjectionGap,`
13	`236`	`Signed192.Signed(probe),`
13	`237`	`radiusDenominator: 1) > 0)`
	`238`	`{`
2	`239`	`return FindProjectedConeCeilingDistance(`
2	`240`	`baseDistance,`
2	`241`	`apexDistance,`
2	`242`	`coordinateDenominator,`
2	`243`	`axisDenominator,`
2	`244`	`axisX,`
2	`245`	`axisY,`
2	`246`	`axisZ,`
2	`247`	`coneHeight,`
2	`248`	`coneRadius,`
2	`249`	`planarAxisSquared,`
2	`250`	`axisSquared,`
2	`251`	`delta,`
2	`252`	`axisProjection,`
2	`253`	`perpendicularProjection,`
2	`254`	`apexProjectionGap,`
2	`255`	`probe + 1L,`
2	`256`	`high);`
	`257`	`}`
	`258`
11	`259`	`high = probe;`
11	`260`	`step = (long)Math.Min(`
11	`261`	`(ulong)step << 1,`
11	`262`	`(ulong)high);`
	`263`	`}`
	`264`
1	`265`	`return 1L;`
	`266`	`}`
	`267`
5	`268`	`long low = candidate + 1L;`
5	`269`	`long upper = maximum.m_rawValue;`
5	`270`	`long upwardStep = 1L;`
10	`271`	`while (low < upper)`
	`272`	`{`
9	`273`	`long remaining = upper - candidate;`
9	`274`	`long probe = candidate + Math.Min(`
9	`275`	`upwardStep,`
9	`276`	`remaining);`
9	`277`	`if (CompareConeDistanceToRadius(`
9	`278`	`baseDistance,`
9	`279`	`apexDistance,`
9	`280`	`coordinateDenominator,`
9	`281`	`axisDenominator,`
9	`282`	`axisX,`
9	`283`	`axisY,`
9	`284`	`axisZ,`
9	`285`	`coneHeight,`
9	`286`	`coneRadius,`
9	`287`	`planarAxisSquared,`
9	`288`	`axisSquared,`
9	`289`	`delta,`
9	`290`	`axisProjection,`
9	`291`	`perpendicularProjection,`
9	`292`	`apexProjectionGap,`
9	`293`	`Signed192.Signed(probe),`
9	`294`	`radiusDenominator: 1) <= 0)`
	`295`	`{`
4	`296`	`return FindProjectedConeCeilingDistance(`
4	`297`	`baseDistance,`
4	`298`	`apexDistance,`
4	`299`	`coordinateDenominator,`
4	`300`	`axisDenominator,`
4	`301`	`axisX,`
4	`302`	`axisY,`
4	`303`	`axisZ,`
4	`304`	`coneHeight,`
4	`305`	`coneRadius,`
4	`306`	`planarAxisSquared,`
4	`307`	`axisSquared,`
4	`308`	`delta,`
4	`309`	`axisProjection,`
4	`310`	`perpendicularProjection,`
4	`311`	`apexProjectionGap,`
4	`312`	`low,`
4	`313`	`probe);`
	`314`	`}`
	`315`
5	`316`	`low = probe + 1L;`
5	`317`	`upwardStep = (long)Math.Min(`
5	`318`	`(ulong)upwardStep << 1,`
5	`319`	`(ulong)(upper - candidate));`
	`320`	`}`
	`321`
1	`322`	`return upper;`
	`323`	`}`
	`324`
	`325`	`private static long FindProjectedConeCeilingDistance(`
	`326`	`RationalDistance baseDistance,`
	`327`	`RationalDistance apexDistance,`
	`328`	`Signed192 coordinateDenominator,`
	`329`	`Signed192 axisDenominator,`
	`330`	`Signed192 axisX,`
	`331`	`Signed192 axisY,`
	`332`	`Signed192 axisZ,`
	`333`	`Fixed64 coneHeight,`
	`334`	`Fixed64 coneRadius,`
	`335`	`Signed320 planarAxisSquared,`
	`336`	`Signed320 axisSquared,`
	`337`	`Signed576 delta,`
	`338`	`Signed576 axisProjection,`
	`339`	`Signed576 perpendicularProjection,`
	`340`	`Signed576 apexProjectionGap,`
	`341`	`long low,`
	`342`	`long high)`
	`343`	`{`
18	`344`	`while (low < high)`
	`345`	`{`
12	`346`	`long middle = low + ((high - low) >> 1);`
12	`347`	`int comparison = CompareConeDistanceToRadius(`
12	`348`	`baseDistance,`
12	`349`	`apexDistance,`
12	`350`	`coordinateDenominator,`
12	`351`	`axisDenominator,`
12	`352`	`axisX,`
12	`353`	`axisY,`
12	`354`	`axisZ,`
12	`355`	`coneHeight,`
12	`356`	`coneRadius,`
12	`357`	`planarAxisSquared,`
12	`358`	`axisSquared,`
12	`359`	`delta,`
12	`360`	`axisProjection,`
12	`361`	`perpendicularProjection,`
12	`362`	`apexProjectionGap,`
12	`363`	`Signed192.Signed(middle),`
12	`364`	`radiusDenominator: 1);`
12	`365`	`if (comparison <= 0)`
5	`366`	`high = middle;`
	`367`	`else`
7	`368`	`low = middle + 1L;`
	`369`	`}`
	`370`
6	`371`	`return low;`
	`372`	`}`
	`373`
	`374`	`private static void GetProjectedConeClosestOffset(`
	`375`	`RationalDistance baseDistance,`
	`376`	`RationalDistance apexDistance,`
	`377`	`Signed192 coordinateDenominator,`
	`378`	`Signed192 axisX,`
	`379`	`Signed192 axisY,`
	`380`	`Signed192 axisZ,`
	`381`	`Fixed64 coneRadius,`
	`382`	`out Fixed64 approximateDistance,`
	`383`	`out Vector2d direction)`
	`384`	`{`
8	`385`	`Signed320 baseX = Signed320.NarrowValue(baseDistance.X);`
8	`386`	`Signed320 baseZ = Signed320.NarrowValue(baseDistance.Z);`
8	`387`	`Signed320 apexX = WideArithmetic.SubtractSigned320(`
8	`388`	`Signed320.NarrowValue(apexDistance.X),`
8	`389`	`baseX);`
8	`390`	`Signed320 apexZ = WideArithmetic.SubtractSigned320(`
8	`391`	`Signed320.NarrowValue(apexDistance.Z),`
8	`392`	`baseZ);`
8	`393`	`Signed320 scaledRadius = WideArithmetic.MultiplySigned192(`
8	`394`	`coordinateDenominator,`
8	`395`	`Signed192.Raw(coneRadius));`
8	`396`	`Signed320 scale = GetLargestPositiveMagnitude(`
8	`397`	`baseX,`
8	`398`	`baseZ,`
8	`399`	`apexX,`
8	`400`	`apexZ,`
8	`401`	`scaledRadius);`
8	`402`	`Vector2d query = new(`
8	`403`	`-Fixed64.GetSignedRatio(baseX, scale),`
8	`404`	`-Fixed64.GetSignedRatio(baseZ, scale));`
8	`405`	`Vector2d apex = new(`
8	`406`	`Fixed64.GetSignedRatio(apexX, scale),`
8	`407`	`Fixed64.GetSignedRatio(apexZ, scale));`
8	`408`	`Vector2d axis = WideNormalization.GetNormalized(axisX, axisZ);`
8	`409`	`Vector2d perpendicular = new(-axis.Y, axis.X);`
8	`410`	`Vector2d localQuery = new(`
8	`411`	`Vector2d.Dot(query, axis),`
8	`412`	`Vector2d.Dot(query, perpendicular));`
8	`413`	`Fixed64 apexLength = Vector2d.Dot(apex, axis);`
8	`414`	`Fixed64 radius = Fixed64.GetSignedRatio(scaledRadius, scale);`
8	`415`	`Fixed64 minor = radius * FixedMath.Abs(`
8	`416`	`WideNormalization.GetNormalized(`
8	`417`	`axisX,`
8	`418`	`axisY,`
8	`419`	`axisZ).Y);`
	`420`	`Vector2d localOffset;`
8	`421`	`if (apexLength <= minor)`
	`422`	`{`
3	`423`	`localOffset = GetEllipseClosestOffset(`
3	`424`	`localQuery.X,`
3	`425`	`localQuery.Y,`
3	`426`	`minor,`
3	`427`	`radius);`
	`428`	`}`
	`429`	`else`
	`430`	`{`
5	`431`	`Fixed64 tangentX = Fixed64.MultiplyDivide(`
5	`432`	`minor,`
5	`433`	`minor,`
5	`434`	`apexLength,`
5	`435`	`out _);`
5	`436`	`Fixed64 ratio = tangentX / apexLength;`
5	`437`	`Fixed64 tangentY = radius * FixedMath.Sqrt(`
5	`438`	`FixedMath.Max(`
5	`439`	`Fixed64.Zero,`
5	`440`	`Fixed64.One - ratio));`
5	`441`	`Vector2d ellipseOffset = GetEllipseClosestOffset(`
5	`442`	`localQuery.X,`
5	`443`	`localQuery.Y,`
5	`444`	`minor,`
5	`445`	`radius);`
5	`446`	`Vector2d ellipsePoint = localQuery + ellipseOffset;`
5	`447`	`bool found = ellipsePoint.X <= tangentX;`
5	`448`	`localOffset = ellipseOffset;`
5	`449`	`KeepCloserOffset(`
5	`450`	`new Vector2d(apexLength, Fixed64.Zero) - localQuery,`
5	`451`	`ref found,`
5	`452`	`ref localOffset);`
5	`453`	`KeepCloserOffset(`
5	`454`	`GetSegmentOffset(`
5	`455`	`localQuery,`
5	`456`	`new Vector2d(tangentX, tangentY),`
5	`457`	`new Vector2d(apexLength, Fixed64.Zero)),`
5	`458`	`ref found,`
5	`459`	`ref localOffset);`
5	`460`	`KeepCloserOffset(`
5	`461`	`GetSegmentOffset(`
5	`462`	`localQuery,`
5	`463`	`new Vector2d(tangentX, -tangentY),`
5	`464`	`new Vector2d(apexLength, Fixed64.Zero)),`
5	`465`	`ref found,`
5	`466`	`ref localOffset);`
	`467`	`}`
	`468`
8	`469`	`Vector2d worldOffset =`
8	`470`	`axis * localOffset.X + perpendicular * localOffset.Y;`
8	`471`	`direction = worldOffset.Normalized;`
8	`472`	`Signed576 distanceNumerator =`
8	`473`	`WideArithmetic.MultiplySigned320(`
8	`474`	`scale,`
8	`475`	`Signed320.ExtendValue(`
8	`476`	`Signed192.Raw(worldOffset.Magnitude)));`
8	`477`	`_ = Fixed64.TryGetSignedRawRatio(`
8	`478`	`distanceNumerator,`
8	`479`	`Signed576.ExtendValue(`
8	`480`	`WideArithmetic.MultiplySigned192(`
8	`481`	`coordinateDenominator,`
8	`482`	`Signed192.Raw(Fixed64.One))),`
8	`483`	`out approximateDistance);`
8	`484`	`}`
	`485`
	`486`	`private static Vector2d GetSegmentOffset(`
	`487`	`Vector2d point,`
	`488`	`Vector2d first,`
	`489`	`Vector2d second)`
	`490`	`{`
10	`491`	`Vector2d edge = second - first;`
10	`492`	`Fixed64 projection = FixedMath.Clamp(`
10	`493`	`Vector2d.Dot(point - first, edge) / edge.MagnitudeSquared,`
10	`494`	`Fixed64.Zero,`
10	`495`	`Fixed64.One);`
10	`496`	`return first + edge * projection - point;`
	`497`	`}`
	`498`
	`499`	`private static void KeepCloserOffset(`
	`500`	`Vector2d candidate,`
	`501`	`ref bool found,`
	`502`	`ref Vector2d best)`
	`503`	`{`
15	`504`	`if (!found \|\| candidate.MagnitudeSquared < best.MagnitudeSquared)`
	`505`	`{`
8	`506`	`found = true;`
8	`507`	`best = candidate;`
	`508`	`}`
15	`509`	`}`
	`510`
	`511`	`private static int CompareConeDistanceToRadius(`
	`512`	`RationalDistance baseDistance,`
	`513`	`RationalDistance apexDistance,`
	`514`	`Signed192 coordinateDenominator,`
	`515`	`Signed192 axisDenominator,`
	`516`	`Signed192 axisX,`
	`517`	`Signed192 axisY,`
	`518`	`Signed192 axisZ,`
	`519`	`Fixed64 coneHeight,`
	`520`	`Fixed64 coneRadius,`
	`521`	`Signed320 planarAxisSquared,`
	`522`	`Signed320 axisSquared,`
	`523`	`Signed576 delta,`
	`524`	`Signed576 axisProjection,`
	`525`	`Signed576 perpendicularProjection,`
	`526`	`Signed576 apexProjectionGap,`
	`527`	`Signed192 radiusNumerator,`
	`528`	`int radiusDenominator)`
	`529`	`{`
71	`530`	`int baseComparison = CompareProjectedDiskDistanceToRadius(`
71	`531`	`baseDistance,`
71	`532`	`coordinateDenominator,`
71	`533`	`axisX,`
71	`534`	`axisY,`
71	`535`	`axisZ,`
71	`536`	`coneRadius,`
71	`537`	`radiusNumerator,`
71	`538`	`radiusDenominator);`
71	`539`	`if (delta.Sign <= 0)`
30	`540`	`return baseComparison;`
	`541`
41	`542`	`if (IsPointInConeProjectionWedge(`
41	`543`	`coordinateDenominator,`
41	`544`	`axisDenominator,`
41	`545`	`axisY,`
41	`546`	`coneHeight,`
41	`547`	`coneRadius,`
41	`548`	`planarAxisSquared,`
41	`549`	`delta,`
41	`550`	`axisProjection,`
41	`551`	`perpendicularProjection,`
41	`552`	`apexProjectionGap))`
	`553`	`{`
4	`554`	`return radiusNumerator.IsZero ? 0 : -1;`
	`555`	`}`
	`556`
37	`557`	`int comparison = Math.Min(`
37	`558`	`baseComparison,`
37	`559`	`CompareRationalDistanceToRadius(`
37	`560`	`apexDistance,`
37	`561`	`radiusNumerator,`
37	`562`	`radiusDenominator));`
37	`563`	`if (TryCompareConeTangentDistanceToRadius(`
37	`564`	`coordinateDenominator,`
37	`565`	`coneHeight,`
37	`566`	`coneRadius,`
37	`567`	`planarAxisSquared,`
37	`568`	`axisSquared,`
37	`569`	`delta,`
37	`570`	`perpendicularProjection,`
37	`571`	`apexProjectionGap,`
37	`572`	`radiusNumerator,`
37	`573`	`radiusDenominator,`
37	`574`	`out int tangentComparison))`
	`575`	`{`
20	`576`	`comparison = Math.Min(`
20	`577`	`comparison,`
20	`578`	`tangentComparison);`
	`579`	`}`
	`580`
37	`581`	`return comparison;`
	`582`	`}`
	`583`
	`584`	`private static void GetConeProjectionData(`
	`585`	`RationalDistance baseDistance,`
	`586`	`Signed192 coordinateDenominator,`
	`587`	`Signed192 axisDenominator,`
	`588`	`Signed192 axisX,`
	`589`	`Signed192 axisY,`
	`590`	`Signed192 axisZ,`
	`591`	`Fixed64 coneHeight,`
	`592`	`Fixed64 coneRadius,`
	`593`	`out Signed320 planarAxisSquared,`
	`594`	`out Signed320 axisSquared,`
	`595`	`out Signed576 delta,`
	`596`	`out Signed576 axisProjection,`
	`597`	`out Signed576 perpendicularProjection,`
	`598`	`out Signed576 apexProjectionGap)`
	`599`	`{`
12	`600`	`Signed320 relativeX = WideArithmetic.SubtractSigned320(`
12	`601`	`default,`
12	`602`	`Signed320.NarrowValue(baseDistance.X));`
12	`603`	`Signed320 relativeZ = WideArithmetic.SubtractSigned320(`
12	`604`	`default,`
12	`605`	`Signed320.NarrowValue(baseDistance.Z));`
12	`606`	`Signed320 axisX2 = WideArithmetic.MultiplySigned192(`
12	`607`	`axisX,`
12	`608`	`axisX);`
12	`609`	`Signed320 axisY2 = WideArithmetic.MultiplySigned192(`
12	`610`	`axisY,`
12	`611`	`axisY);`
12	`612`	`Signed320 axisZ2 = WideArithmetic.MultiplySigned192(`
12	`613`	`axisZ,`
12	`614`	`axisZ);`
12	`615`	`planarAxisSquared = WideArithmetic.AddSigned320(`
12	`616`	`axisX2,`
12	`617`	`axisZ2);`
12	`618`	`axisSquared = WideArithmetic.AddSigned320(`
12	`619`	`planarAxisSquared,`
12	`620`	`axisY2);`
12	`621`	`Signed320 heightSquared = WideArithmetic.MultiplySigned192(`
12	`622`	`Signed192.Raw(coneHeight),`
12	`623`	`Signed192.Raw(coneHeight));`
12	`624`	`Signed320 radiusSquared = WideArithmetic.MultiplySigned192(`
12	`625`	`Signed192.Raw(coneRadius),`
12	`626`	`Signed192.Raw(coneRadius));`
12	`627`	`delta = WideArithmetic.SubtractSigned576(`
12	`628`	`WideArithmetic.MultiplySigned320(`
12	`629`	`heightSquared,`
12	`630`	`planarAxisSquared),`
12	`631`	`WideArithmetic.MultiplySigned320(`
12	`632`	`radiusSquared,`
12	`633`	`axisY2));`
12	`634`	`axisProjection = WideArithmetic.AddSigned576(`
12	`635`	`WideArithmetic.MultiplySigned320(`
12	`636`	`relativeX,`
12	`637`	`Signed320.ExtendValue(axisX)),`
12	`638`	`WideArithmetic.MultiplySigned320(`
12	`639`	`relativeZ,`
12	`640`	`Signed320.ExtendValue(axisZ)));`
12	`641`	`perpendicularProjection = WideArithmetic.SubtractSigned576(`
12	`642`	`WideArithmetic.MultiplySigned320(`
12	`643`	`relativeZ,`
12	`644`	`Signed320.ExtendValue(axisX)),`
12	`645`	`WideArithmetic.MultiplySigned320(`
12	`646`	`relativeX,`
12	`647`	`Signed320.ExtendValue(axisZ)));`
12	`648`	`Signed576 heightTerm = WideArithmetic.MultiplySigned576(`
12	`649`	`WideArithmetic.MultiplySigned576(`
12	`650`	`Signed576.ExtendValue(planarAxisSquared),`
12	`651`	`Signed192.Raw(coneHeight)),`
12	`652`	`coordinateDenominator);`
12	`653`	`Signed576 projectionTerm = WideArithmetic.MultiplySigned576(`
12	`654`	`axisProjection,`
12	`655`	`axisDenominator);`
12	`656`	`apexProjectionGap = WideArithmetic.SubtractSigned576(`
12	`657`	`heightTerm,`
12	`658`	`projectionTerm);`
12	`659`	`}`
	`660`
	`661`	`private static bool IsPointInConeProjectionWedge(`
	`662`	`Signed192 coordinateDenominator,`
	`663`	`Signed192 axisDenominator,`
	`664`	`Signed192 axisY,`
	`665`	`Fixed64 coneHeight,`
	`666`	`Fixed64 coneRadius,`
	`667`	`Signed320 planarAxisSquared,`
	`668`	`Signed576 delta,`
	`669`	`Signed576 axisProjection,`
	`670`	`Signed576 perpendicularProjection,`
	`671`	`Signed576 apexProjectionGap)`
	`672`	`{`
41	`673`	`if (apexProjectionGap.Sign < 0)`
9	`674`	`return false;`
	`675`
32	`676`	`Signed576 tangentStartLeft = WideArithmetic.MultiplySigned576(`
32	`677`	`WideArithmetic.MultiplySigned576(`
32	`678`	`axisProjection,`
32	`679`	`Signed192.Raw(coneHeight)),`
32	`680`	`axisDenominator);`
32	`681`	`Signed576 tangentStartRight = WideArithmetic.MultiplySigned576(`
32	`682`	`WideArithmetic.MultiplySigned320(`
32	`683`	`WideArithmetic.MultiplySigned192(`
32	`684`	`Signed192.Raw(coneRadius),`
32	`685`	`Signed192.Raw(coneRadius)),`
32	`686`	`WideArithmetic.MultiplySigned192(`
32	`687`	`axisY,`
32	`688`	`axisY)),`
32	`689`	`coordinateDenominator);`
32	`690`	`if (WideArithmetic.SubtractSigned576(`
32	`691`	`tangentStartLeft,`
32	`692`	`tangentStartRight).Sign < 0)`
	`693`	`{`
8	`694`	`return false;`
	`695`	`}`
	`696`
24	`697`	`Signed576 absolutePerpendicular =`
24	`698`	`WideArithmetic.Absolute(perpendicularProjection);`
24	`699`	`Signed576 radiusGap = WideArithmetic.MultiplySigned576(`
24	`700`	`apexProjectionGap,`
24	`701`	`Signed192.Raw(coneRadius));`
24	`702`	`return WideArithmetic.CompareSignedLinearRadicalToZero(`
24	`703`	`Signed832.ExtendValue(`
24	`704`	`WideArithmetic.SubtractSigned576(`
24	`705`	`default,`
24	`706`	`radiusGap)),`
24	`707`	`Signed704.ExtendValue(absolutePerpendicular),`
24	`708`	`delta,`
24	`709`	`Signed320.ExtendValue(Signed192.Signed(1L))) <= 0;`
	`710`	`}`
	`711`
	`712`	`private static bool TryCompareConeTangentDistanceToRadius(`
	`713`	`Signed192 coordinateDenominator,`
	`714`	`Fixed64 coneHeight,`
	`715`	`Fixed64 coneRadius,`
	`716`	`Signed320 planarAxisSquared,`
	`717`	`Signed320 axisSquared,`
	`718`	`Signed576 delta,`
	`719`	`Signed576 perpendicularProjection,`
	`720`	`Signed576 apexProjectionGap,`
	`721`	`Signed192 radiusNumerator,`
	`722`	`int radiusDenominator,`
	`723`	`out int comparison)`
	`724`	`{`
37	`725`	`Signed576 absolutePerpendicular =`
37	`726`	`WideArithmetic.Absolute(perpendicularProjection);`
37	`727`	`Signed576 radiusPerpendicular = WideArithmetic.MultiplySigned576(`
37	`728`	`absolutePerpendicular,`
37	`729`	`Signed192.Raw(coneRadius));`
37	`730`	`Signed704 lowerRational =`
37	`731`	`WideArithmetic.MultiplySigned576ToSigned704(`
37	`732`	`radiusPerpendicular,`
37	`733`	`axisSquared);`
37	`734`	`int lowerGate = WideArithmetic.CompareSignedLinearRadicalToZero(`
37	`735`	`Signed832.ExtendValue(lowerRational),`
37	`736`	`Signed704.ExtendValue(apexProjectionGap),`
37	`737`	`delta,`
37	`738`	`Signed320.ExtendValue(Signed192.Signed(1L)));`
37	`739`	`if (lowerGate <= 0)`
	`740`	`{`
9	`741`	`comparison = default;`
9	`742`	`return false;`
	`743`	`}`
	`744`
28	`745`	`Signed320 sideSquared = WideArithmetic.AddSigned320(`
28	`746`	`WideArithmetic.MultiplySigned192(`
28	`747`	`Signed192.Raw(coneHeight),`
28	`748`	`Signed192.Raw(coneHeight)),`
28	`749`	`WideArithmetic.MultiplySigned192(`
28	`750`	`Signed192.Raw(coneRadius),`
28	`751`	`Signed192.Raw(coneRadius)));`
28	`752`	`Signed576 upperCoefficient = WideArithmetic.SubtractSigned576(`
28	`753`	`WideArithmetic.MultiplySigned576(`
28	`754`	`apexProjectionGap,`
28	`755`	`Signed192.Raw(coneHeight)),`
28	`756`	`WideArithmetic.MultiplySigned576(`
28	`757`	`WideArithmetic.MultiplySigned320(`
28	`758`	`sideSquared,`
28	`759`	`planarAxisSquared),`
28	`760`	`coordinateDenominator));`
28	`761`	`Signed576 heightRadiusPerpendicular =`
28	`762`	`WideArithmetic.MultiplySigned576(`
28	`763`	`absolutePerpendicular,`
28	`764`	`Signed192.Raw(coneHeight),`
28	`765`	`Signed192.Raw(coneRadius));`
28	`766`	`Signed704 upperRational =`
28	`767`	`WideArithmetic.MultiplySigned576ToSigned704(`
28	`768`	`heightRadiusPerpendicular,`
28	`769`	`axisSquared);`
28	`770`	`int upperGate = WideArithmetic.CompareSignedLinearRadicalToZero(`
28	`771`	`Signed832.ExtendValue(upperRational),`
28	`772`	`Signed704.ExtendValue(upperCoefficient),`
28	`773`	`delta,`
28	`774`	`Signed320.ExtendValue(Signed192.Signed(1L)));`
28	`775`	`if (upperGate >= 0)`
	`776`	`{`
8	`777`	`comparison = default;`
8	`778`	`return false;`
	`779`	`}`
	`780`
20	`781`	`Signed576 radiusGap = WideArithmetic.MultiplySigned576(`
20	`782`	`apexProjectionGap,`
20	`783`	`Signed192.Raw(coneRadius));`
20	`784`	`comparison = CompareConeTangentSquaredDistance(`
20	`785`	`absolutePerpendicular,`
20	`786`	`delta,`
20	`787`	`radiusGap,`
20	`788`	`coordinateDenominator,`
20	`789`	`planarAxisSquared,`
20	`790`	`sideSquared,`
20	`791`	`radiusNumerator,`
20	`792`	`radiusDenominator);`
20	`793`	`return true;`
	`794`	`}`
	`795`
	`796`	`private static int CompareConeTangentSquaredDistance(`
	`797`	`Signed576 radicalCoefficient,`
	`798`	`Signed576 radicand,`
	`799`	`Signed576 rationalMagnitude,`
	`800`	`Signed192 coordinateDenominator,`
	`801`	`Signed320 planarAxisSquared,`
	`802`	`Signed320 sideSquared,`
	`803`	`Signed192 radiusNumerator,`
	`804`	`int radiusDenominator)`
	`805`	`{`
20	`806`	`Span<ulong> first = stackalloc ulong[ConeComparisonWordCount];`
20	`807`	`Span<ulong> second = stackalloc ulong[ConeComparisonWordCount];`
20	`808`	`Span<ulong> third = stackalloc ulong[ConeComparisonWordCount];`
20	`809`	`Span<ulong> result = stackalloc ulong[ConeComparisonWordCount];`
20	`810`	`Span<ulong> other = stackalloc ulong[ConeComparisonWordCount];`
20	`811`	`Span<ulong> coefficient = stackalloc ulong[ConeComparisonWordCount];`
20	`812`	`Span<ulong> delta = stackalloc ulong[ConeComparisonWordCount];`
20	`813`	`Span<ulong> rational = stackalloc ulong[ConeComparisonWordCount];`
20	`814`	`Span<ulong> radius = stackalloc ulong[ConeComparisonWordCount];`
20	`815`	`Span<ulong> denominator = stackalloc ulong[ConeComparisonWordCount];`
20	`816`	`Span<ulong> planar = stackalloc ulong[ConeComparisonWordCount];`
20	`817`	`Span<ulong> side = stackalloc ulong[ConeComparisonWordCount];`
20	`818`	`first.Clear();`
20	`819`	`second.Clear();`
20	`820`	`third.Clear();`
20	`821`	`result.Clear();`
20	`822`	`other.Clear();`
20	`823`	`coefficient.Clear();`
20	`824`	`delta.Clear();`
20	`825`	`rational.Clear();`
20	`826`	`radius.Clear();`
20	`827`	`denominator.Clear();`
20	`828`	`planar.Clear();`
20	`829`	`side.Clear();`
20	`830`	`WideArithmetic.GetMagnitude(radicalCoefficient, coefficient);`
20	`831`	`WideArithmetic.GetMagnitude(radicand, delta);`
20	`832`	`WideArithmetic.GetMagnitude(rationalMagnitude, rational);`
20	`833`	`WideArithmetic.GetMagnitude(`
20	`834`	`radiusNumerator,`
20	`835`	`out radius[2],`
20	`836`	`out radius[1],`
20	`837`	`out radius[0]);`
20	`838`	`WideArithmetic.GetMagnitude(`
20	`839`	`coordinateDenominator,`
20	`840`	`out denominator[2],`
20	`841`	`out denominator[1],`
20	`842`	`out denominator[0]);`
20	`843`	`WideArithmetic.GetMagnitude(`
20	`844`	`planarAxisSquared,`
20	`845`	`out planar[4],`
20	`846`	`out planar[3],`
20	`847`	`out planar[2],`
20	`848`	`out planar[1],`
20	`849`	`out planar[0]);`
20	`850`	`WideArithmetic.GetMagnitude(`
20	`851`	`sideSquared,`
20	`852`	`out side[4],`
20	`853`	`out side[3],`
20	`854`	`out side[2],`
20	`855`	`out side[1],`
20	`856`	`out side[0]);`
	`857`
20	`858`	`WideArithmetic.MultiplyMagnitudes(`
20	`859`	`coefficient,`
20	`860`	`coefficient,`
20	`861`	`first);`
20	`862`	`WideArithmetic.MultiplyMagnitudes(first, delta, second);`
20	`863`	`WideArithmetic.MultiplyMagnitudes(rational, rational, first);`
20	`864`	`WideArithmetic.AddEqualMagnitudes(second, first, result);`
20	`865`	`if (radiusDenominator == 2)`
	`866`	`{`
3	`867`	`result.CopyTo(first);`
3	`868`	`WideArithmetic.AddEqualMagnitudes(first, first, second);`
3	`869`	`WideArithmetic.AddEqualMagnitudes(second, second, result);`
	`870`	`}`
	`871`
20	`872`	`WideArithmetic.MultiplyMagnitudes(radius, radius, first);`
20	`873`	`WideArithmetic.MultiplyMagnitudes(`
20	`874`	`denominator,`
20	`875`	`denominator,`
20	`876`	`second);`
20	`877`	`WideArithmetic.MultiplyMagnitudes(first, second, third);`
20	`878`	`WideArithmetic.MultiplyMagnitudes(planar, planar, first);`
20	`879`	`WideArithmetic.MultiplyMagnitudes(third, first, second);`
20	`880`	`WideArithmetic.MultiplyMagnitudes(second, side, other);`
	`881`
20	`882`	`int rationalComparison =`
20	`883`	`WideArithmetic.CompareMagnitudeEqualLength(result, other);`
20	`884`	`if (rationalComparison <= 0)`
1	`885`	`return -1;`
19	`886`	`WideArithmetic.SubtractEqualMagnitudes(`
19	`887`	`result,`
19	`888`	`other,`
19	`889`	`rational);`
	`890`
19	`891`	`WideArithmetic.GetMagnitude(rationalMagnitude, result);`
19	`892`	`WideArithmetic.MultiplyMagnitudes(coefficient, result, first);`
19	`893`	`first.CopyTo(second);`
19	`894`	`WideArithmetic.AddEqualMagnitudes(second, second, first);`
19	`895`	`if (radiusDenominator == 2)`
	`896`	`{`
3	`897`	`first.CopyTo(second);`
3	`898`	`WideArithmetic.AddEqualMagnitudes(second, second, first);`
3	`899`	`first.CopyTo(second);`
3	`900`	`WideArithmetic.AddEqualMagnitudes(second, second, first);`
	`901`	`}`
19	`902`	`WideArithmetic.MultiplyMagnitudes(first, first, second);`
19	`903`	`WideArithmetic.MultiplyMagnitudes(second, delta, other);`
19	`904`	`WideArithmetic.MultiplyMagnitudes(rational, rational, result);`
19	`905`	`return WideArithmetic.CompareMagnitudeEqualLength(result, other);`
	`906`	`}`
	`907`
	`908`	`private static int CompareRationalDistanceToRadius(`
	`909`	`RationalDistance distance,`
	`910`	`Signed192 radiusNumerator,`
	`911`	`int radiusDenominator) =>`
37	`912`	`radiusDenominator == 1`
37	`913`	`? CompareDistanceToRaw(distance, radiusNumerator)`
37	`914`	`: CompareDistanceToTwiceRaw(distance, radiusNumerator);`
	`915`
	`916`	`}`

/home/runner/work/FixedMathSharp/FixedMathSharp/src/FixedMathSharp/Geometry/Wide/Common/WidePlanarProjection.cs

#	Line	Line coverage
	`1`	`//=======================================================================`
	`2`	`// WidePlanarProjection.cs`
	`3`	`//=======================================================================`
	`4`	`// MIT License, Copyright (c) 2024-present David Oravsky (mrdav30)`
	`5`	`// See LICENSE file in the project root for full license information.`
	`6`	`//=======================================================================`
	`7`
	`8`	`using System;`
	`9`
	`10`	`namespace FixedMathSharp.Geometry;`
	`11`
	`12`	`/// <summary>`
	`13`	`/// Owns exact point relations to complete X/Z projections without`
	`14`	`/// materializing conceptual world-space features.`
	`15`	`/// </summary>`
	`16`	`internal static partial class WidePlanarProjection`
	`17`	`{`
	`18`	`#region Nested Types`
	`19`
	`20`	`private readonly struct RationalPoint`
	`21`	`{`
	`22`	`internal RationalPoint(Signed320 x, Signed320 z)`
	`23`	`{`
2239	`24`	`X = x;`
2239	`25`	`Z = z;`
2239	`26`	`}`
	`27`
	`28`	`internal readonly Signed320 X;`
	`29`	`internal readonly Signed320 Z;`
	`30`	`}`
	`31`
	`32`	`private readonly struct RationalDistance`
	`33`	`{`
	`34`	`internal RationalDistance(`
	`35`	`Signed576 x,`
	`36`	`Signed576 z,`
	`37`	`Signed576 denominator)`
	`38`	`{`
2178	`39`	`X = x;`
2178	`40`	`Z = z;`
2178	`41`	`Denominator = denominator;`
2178	`42`	`SquaredDistance = WideArithmetic.AddSigned832(`
2178	`43`	`WideArithmetic.MultiplySigned576ToSigned832(x, x),`
2178	`44`	`WideArithmetic.MultiplySigned576ToSigned832(z, z));`
2178	`45`	`}`
	`46`
	`47`	`internal readonly Signed576 X;`
	`48`	`internal readonly Signed576 Z;`
	`49`	`internal readonly Signed576 Denominator;`
	`50`	`internal readonly Signed832 SquaredDistance;`
	`51`	`}`
	`52`
	`53`	`#endregion`
	`54`
	`55`	`internal static bool AreSegmentEndpointDistancesAtLeast(`
	`56`	`FixedSegment2d first,`
	`57`	`FixedSegment2d second,`
	`58`	`Fixed64 minimumDistance)`
	`59`	`{`
527	`60`	`Signed192 denominator = Signed192.Signed(1L);`
527	`61`	`RationalPoint firstStart = GetRawPoint(first.Start);`
527	`62`	`RationalPoint firstEnd = GetRawPoint(first.End);`
527	`63`	`RationalPoint secondStart = GetRawPoint(second.Start);`
527	`64`	`RationalPoint secondEnd = GetRawPoint(second.End);`
527	`65`	`Signed192 minimumRaw = Signed192.Raw(minimumDistance);`
	`66`
527	`67`	`return CompareDistanceToRaw(`
527	`68`	`GetSegmentDistance(`
527	`69`	`first.Start,`
527	`70`	`denominator,`
527	`71`	`secondStart,`
527	`72`	`secondEnd),`
527	`73`	`minimumRaw) >= 0`
527	`74`	`&& CompareDistanceToRaw(`
527	`75`	`GetSegmentDistance(`
527	`76`	`first.End,`
527	`77`	`denominator,`
527	`78`	`secondStart,`
527	`79`	`secondEnd),`
527	`80`	`minimumRaw) >= 0`
527	`81`	`&& CompareDistanceToRaw(`
527	`82`	`GetSegmentDistance(`
527	`83`	`second.Start,`
527	`84`	`denominator,`
527	`85`	`firstStart,`
527	`86`	`firstEnd),`
527	`87`	`minimumRaw) >= 0`
527	`88`	`&& CompareDistanceToRaw(`
527	`89`	`GetSegmentDistance(`
527	`90`	`second.End,`
527	`91`	`denominator,`
527	`92`	`firstStart,`
527	`93`	`firstEnd),`
527	`94`	`minimumRaw) >= 0;`
	`95`	`}`
	`96`
	`97`	`private static RationalPoint GetRawPoint(Vector2d point) =>`
2108	`98`	`new(`
2108	`99`	`Signed320.ExtendValue(Signed192.Raw(point.X)),`
2108	`100`	`Signed320.ExtendValue(Signed192.Raw(point.Y)));`
	`101`
	`102`	`internal static bool TryGetSphereRelation(`
	`103`	`Vector2d circleCenter,`
	`104`	`Fixed64 circleRadius,`
	`105`	`Vector3d sphereCenter,`
	`106`	`Fixed64 sphereRadius,`
	`107`	`out PlanarProjectionRelation relation)`
	`108`	`{`
3	`109`	`Vector2d projectedCenter = new(`
3	`110`	`sphereCenter.X,`
3	`111`	`sphereCenter.Z);`
3	`112`	`if (WideGeometry.CompareDistanceToRadiusSum(`
3	`113`	`circleCenter,`
3	`114`	`projectedCenter,`
3	`115`	`circleRadius,`
3	`116`	`sphereRadius) > 0)`
	`117`	`{`
1	`118`	`relation = default;`
1	`119`	`return false;`
	`120`	`}`
	`121`
2	`122`	`if (WideGeometry.CompareDistanceToRadiusSum(`
2	`123`	`circleCenter,`
2	`124`	`projectedCenter,`
2	`125`	`Fixed64.Zero,`
2	`126`	`sphereRadius) <= 0)`
	`127`	`{`
1	`128`	`relation = PlanarProjectionRelation.Contained;`
1	`129`	`return true;`
	`130`	`}`
	`131`
1	`132`	`_ = WideFiniteAxisIntersection.TryGetDistanceToCenteredCapsule(`
1	`133`	`circleCenter,`
1	`134`	`projectedCenter,`
1	`135`	`Vector2d.Right,`
1	`136`	`Fixed64.Zero,`
1	`137`	`sphereRadius,`
1	`138`	`out Fixed64 distance);`
	`139`
1	`140`	`Vector2d normal =`
1	`141`	`WideNormalization.GetDirection(projectedCenter, circleCenter);`
1	`142`	`relation = new PlanarProjectionRelation(`
1	`143`	`distance,`
1	`144`	`-normal * distance,`
1	`145`	`-normal);`
1	`146`	`return true;`
	`147`	`}`
	`148`
	`149`	`internal static bool TryGetCenteredCapsuleRelation(`
	`150`	`Vector2d circleCenter,`
	`151`	`Fixed64 circleRadius,`
	`152`	`Vector3d capsuleCenter,`
	`153`	`FixedQuaternion capsuleRotation,`
	`154`	`Vector3d capsuleLocalAxis,`
	`155`	`Fixed64 capsuleAxisLength,`
	`156`	`Fixed64 capsuleRadius,`
	`157`	`out PlanarProjectionRelation relation)`
	`158`	`{`
6	`159`	`WideRationalBasis3d basis = new(capsuleRotation);`
6	`160`	`GetRotatedLocalAxis(`
6	`161`	`basis,`
6	`162`	`capsuleLocalAxis,`
6	`163`	`out Signed320 axisX,`
6	`164`	`out _,`
6	`165`	`out Signed320 axisZ);`
6	`166`	`GetCenteredAxisEndpoints(`
6	`167`	`capsuleCenter,`
6	`168`	`basis.Denominator,`
6	`169`	`axisX,`
6	`170`	`axisZ,`
6	`171`	`capsuleAxisLength,`
6	`172`	`out Signed192 axisDenominator,`
6	`173`	`out RationalPoint first,`
6	`174`	`out RationalPoint second);`
6	`175`	`RationalDistance axisDistance = GetSegmentDistance(`
6	`176`	`circleCenter,`
6	`177`	`axisDenominator,`
6	`178`	`first,`
6	`179`	`second);`
6	`180`	`return TryCreateRadiallyExpandedRelation(`
6	`181`	`axisDistance,`
6	`182`	`capsuleRadius,`
6	`183`	`circleRadius,`
6	`184`	`out relation);`
	`185`	`}`
	`186`
	`187`	`internal static bool TryGetCenteredCylinderRelation(`
	`188`	`Vector2d circleCenter,`
	`189`	`Fixed64 circleRadius,`
	`190`	`Vector3d cylinderCenter,`
	`191`	`FixedQuaternion cylinderRotation,`
	`192`	`Fixed64 cylinderAxisLength,`
	`193`	`Fixed64 cylinderRadius,`
	`194`	`out PlanarProjectionRelation relation)`
	`195`	`{`
16	`196`	`WideRationalBasis3d basis = new(cylinderRotation);`
16	`197`	`Signed192 axisX = basis.Yx;`
16	`198`	`Signed192 axisY = basis.Yy;`
16	`199`	`Signed192 axisZ = basis.Yz;`
16	`200`	`GetCenteredBasisAxisEndpoints(`
16	`201`	`cylinderCenter,`
16	`202`	`basis.Denominator,`
16	`203`	`axisX,`
16	`204`	`axisZ,`
16	`205`	`cylinderAxisLength,`
16	`206`	`out Signed192 axisDenominator,`
16	`207`	`out RationalPoint first,`
16	`208`	`out RationalPoint second);`
16	`209`	`RationalDistance axisDistance = GetSegmentDistance(`
16	`210`	`circleCenter,`
16	`211`	`axisDenominator,`
16	`212`	`first,`
16	`213`	`second,`
16	`214`	`out int feature);`
16	`215`	`if (feature == 0)`
	`216`	`{`
3	`217`	`return TryCreateRadiallyExpandedRelation(`
3	`218`	`axisDistance,`
3	`219`	`cylinderRadius,`
3	`220`	`circleRadius,`
3	`221`	`out relation);`
	`222`	`}`
	`223`
13	`224`	`return TryGetProjectedDiskRelation(`
13	`225`	`circleCenter,`
13	`226`	`circleRadius,`
13	`227`	`feature < 0 ? first : second,`
13	`228`	`axisDenominator,`
13	`229`	`axisX,`
13	`230`	`axisY,`
13	`231`	`axisZ,`
13	`232`	`cylinderRadius,`
13	`233`	`out relation);`
	`234`	`}`
	`235`
	`236`	`internal static bool TryGetCenteredConeRelation(`
	`237`	`Vector2d circleCenter,`
	`238`	`Fixed64 circleRadius,`
	`239`	`Vector3d coneCenter,`
	`240`	`FixedQuaternion coneRotation,`
	`241`	`Fixed64 coneHeight,`
	`242`	`Fixed64 coneRadius,`
	`243`	`out PlanarProjectionRelation relation)`
	`244`	`{`
14	`245`	`WideRationalBasis3d basis = new(coneRotation);`
14	`246`	`Signed192 axisX = basis.Yx;`
14	`247`	`Signed192 axisY = basis.Yy;`
14	`248`	`Signed192 axisZ = basis.Yz;`
14	`249`	`GetCenteredBasisAxisEndpoints(`
14	`250`	`coneCenter,`
14	`251`	`basis.Denominator,`
14	`252`	`axisX,`
14	`253`	`axisZ,`
14	`254`	`coneHeight,`
14	`255`	`out Signed192 axisDenominator,`
14	`256`	`out RationalPoint baseCenter,`
14	`257`	`out RationalPoint apex);`
14	`258`	`if (axisY.IsZero)`
	`259`	`{`
1	`260`	`GetProjectedDiskSegmentEndpoints(`
1	`261`	`baseCenter,`
1	`262`	`axisX,`
1	`263`	`axisZ,`
1	`264`	`coneRadius,`
1	`265`	`out RationalPoint first,`
1	`266`	`out RationalPoint second);`
1	`267`	`Span<RationalPoint> triangle =`
1	`268`	`stackalloc RationalPoint[3];`
1	`269`	`triangle[0] = first;`
1	`270`	`triangle[1] = second;`
1	`271`	`triangle[2] = apex;`
1	`272`	`return TryGetConvexRelation(`
1	`273`	`circleCenter,`
1	`274`	`circleRadius,`
1	`275`	`axisDenominator,`
1	`276`	`triangle,`
1	`277`	`out relation);`
	`278`	`}`
13	`279`	`if (axisX.IsZero && axisZ.IsZero)`
	`280`	`{`
1	`281`	`return TryGetProjectedDiskRelation(`
1	`282`	`circleCenter,`
1	`283`	`circleRadius,`
1	`284`	`baseCenter,`
1	`285`	`axisDenominator,`
1	`286`	`axisX,`
1	`287`	`axisY,`
1	`288`	`axisZ,`
1	`289`	`coneRadius,`
1	`290`	`out relation);`
	`291`	`}`
	`292`
12	`293`	`return TryGetRotatedConeRelation(`
12	`294`	`circleCenter,`
12	`295`	`circleRadius,`
12	`296`	`baseCenter,`
12	`297`	`apex,`
12	`298`	`axisDenominator,`
12	`299`	`basis.Denominator,`
12	`300`	`axisX,`
12	`301`	`axisY,`
12	`302`	`axisZ,`
12	`303`	`coneHeight,`
12	`304`	`coneRadius,`
12	`305`	`out relation);`
	`306`	`}`
	`307`
	`308`	`private static bool TryCreateRadiallyExpandedRelation(`
	`309`	`RationalDistance axisDistance,`
	`310`	`Fixed64 shapeRadius,`
	`311`	`Fixed64 queryRadius,`
	`312`	`out PlanarProjectionRelation relation)`
	`313`	`{`
11	`314`	`Signed576 shapeRadiusNumerator =`
11	`315`	`WideArithmetic.MultiplySigned576(`
11	`316`	`axisDistance.Denominator,`
11	`317`	`Signed192.Raw(shapeRadius));`
11	`318`	`Signed832 shapeRadiusSquared =`
11	`319`	`WideArithmetic.MultiplySigned576ToSigned832(`
11	`320`	`shapeRadiusNumerator,`
11	`321`	`shapeRadiusNumerator);`
11	`322`	`if (WideArithmetic.SubtractSigned832(`
11	`323`	`axisDistance.SquaredDistance,`
11	`324`	`shapeRadiusSquared).Sign <= 0)`
	`325`	`{`
2	`326`	`relation = PlanarProjectionRelation.Contained;`
2	`327`	`return true;`
	`328`	`}`
	`329`
9	`330`	`if (!TryGetRadialGap(`
9	`331`	`axisDistance,`
9	`332`	`shapeRadius,`
9	`333`	`queryRadius,`
9	`334`	`out Fixed64 distance))`
	`335`	`{`
2	`336`	`relation = default;`
2	`337`	`return false;`
	`338`	`}`
	`339`
7	`340`	`Vector2d direction = WideNormalization.GetNormalized(`
7	`341`	`axisDistance.X,`
7	`342`	`axisDistance.Z);`
7	`343`	`Vector2d offset = direction * distance;`
7	`344`	`relation = new PlanarProjectionRelation(`
7	`345`	`distance,`
7	`346`	`offset,`
7	`347`	`direction);`
7	`348`	`return true;`
	`349`	`}`
	`350`
	`351`	`private static void GetRotatedLocalAxis(`
	`352`	`WideRationalBasis3d basis,`
	`353`	`Vector3d localAxis,`
	`354`	`out Signed320 x,`
	`355`	`out Signed320 y,`
	`356`	`out Signed320 z)`
	`357`	`{`
6	`358`	`x = GetLocalOffsetNumerator(`
6	`359`	`basis.Xx,`
6	`360`	`basis.Yx,`
6	`361`	`basis.Zx,`
6	`362`	`localAxis);`
6	`363`	`y = GetLocalOffsetNumerator(`
6	`364`	`basis.Xy,`
6	`365`	`basis.Yy,`
6	`366`	`basis.Zy,`
6	`367`	`localAxis);`
6	`368`	`z = GetLocalOffsetNumerator(`
6	`369`	`basis.Xz,`
6	`370`	`basis.Yz,`
6	`371`	`basis.Zz,`
6	`372`	`localAxis);`
6	`373`	`}`
	`374`
	`375`	`private static Signed320 GetLocalOffsetNumerator(`
	`376`	`Signed192 x,`
	`377`	`Signed192 y,`
	`378`	`Signed192 z,`
	`379`	`Vector3d localPoint) =>`
128	`380`	`WideArithmetic.AddSigned320(`
128	`381`	`WideArithmetic.AddSigned320(`
128	`382`	`WideArithmetic.MultiplySigned192(`
128	`383`	`x,`
128	`384`	`Signed192.Raw(localPoint.X)),`
128	`385`	`WideArithmetic.MultiplySigned192(`
128	`386`	`y,`
128	`387`	`Signed192.Raw(localPoint.Y))),`
128	`388`	`WideArithmetic.MultiplySigned192(`
128	`389`	`z,`
128	`390`	`Signed192.Raw(localPoint.Z)));`
	`391`
	`392`	`private static RationalPoint GetWorldPoint(`
	`393`	`Vector3d origin,`
	`394`	`WideRationalBasis3d basis,`
	`395`	`Vector3d localPoint) =>`
55	`396`	`new(`
55	`397`	`WideArithmetic.AddSigned320(`
55	`398`	`WideArithmetic.MultiplySigned192(`
55	`399`	`Signed192.Raw(origin.X),`
55	`400`	`basis.Denominator),`
55	`401`	`GetLocalOffsetNumerator(`
55	`402`	`basis.Xx,`
55	`403`	`basis.Yx,`
55	`404`	`basis.Zx,`
55	`405`	`localPoint)),`
55	`406`	`WideArithmetic.AddSigned320(`
55	`407`	`WideArithmetic.MultiplySigned192(`
55	`408`	`Signed192.Raw(origin.Z),`
55	`409`	`basis.Denominator),`
55	`410`	`GetLocalOffsetNumerator(`
55	`411`	`basis.Xz,`
55	`412`	`basis.Yz,`
55	`413`	`basis.Zz,`
55	`414`	`localPoint)));`
	`415`
	`416`	`private static void GetCenteredAxisEndpoints(`
	`417`	`Vector3d center,`
	`418`	`Signed192 denominator,`
	`419`	`Signed320 axisX,`
	`420`	`Signed320 axisZ,`
	`421`	`Fixed64 axisLength,`
	`422`	`out Signed192 axisDenominator,`
	`423`	`out RationalPoint first,`
	`424`	`out RationalPoint second)`
	`425`	`{`
6	`426`	`Signed192 halfLengthNumerator =`
6	`427`	`Signed192.Signed(axisLength.m_rawValue);`
6	`428`	`axisDenominator = Signed192.NarrowValue(`
6	`429`	`WideArithmetic.AddSigned320(`
6	`430`	`WideArithmetic.MultiplySigned192(`
6	`431`	`denominator,`
6	`432`	`Signed192.Raw(Fixed64.One)),`
6	`433`	`WideArithmetic.MultiplySigned192(`
6	`434`	`denominator,`
6	`435`	`Signed192.Raw(Fixed64.One))));`
6	`436`	`Signed320 centerX = WideArithmetic.MultiplySigned192(`
6	`437`	`Signed192.Raw(center.X),`
6	`438`	`axisDenominator);`
6	`439`	`Signed320 centerZ = WideArithmetic.MultiplySigned192(`
6	`440`	`Signed192.Raw(center.Z),`
6	`441`	`axisDenominator);`
6	`442`	`Signed320 offsetX = Signed320.NarrowValue(`
6	`443`	`WideArithmetic.MultiplySigned320(`
6	`444`	`axisX,`
6	`445`	`Signed320.ExtendValue(halfLengthNumerator)));`
6	`446`	`Signed320 offsetZ = Signed320.NarrowValue(`
6	`447`	`WideArithmetic.MultiplySigned320(`
6	`448`	`axisZ,`
6	`449`	`Signed320.ExtendValue(halfLengthNumerator)));`
6	`450`	`first = new RationalPoint(`
6	`451`	`WideArithmetic.SubtractSigned320(centerX, offsetX),`
6	`452`	`WideArithmetic.SubtractSigned320(centerZ, offsetZ));`
6	`453`	`second = new RationalPoint(`
6	`454`	`WideArithmetic.AddSigned320(centerX, offsetX),`
6	`455`	`WideArithmetic.AddSigned320(centerZ, offsetZ));`
6	`456`	`}`
	`457`
	`458`	`private static void GetCenteredBasisAxisEndpoints(`
	`459`	`Vector3d center,`
	`460`	`Signed192 denominator,`
	`461`	`Signed192 axisX,`
	`462`	`Signed192 axisZ,`
	`463`	`Fixed64 axisLength,`
	`464`	`out Signed192 axisDenominator,`
	`465`	`out RationalPoint first,`
	`466`	`out RationalPoint second)`
	`467`	`{`
30	`468`	`axisDenominator = WideArithmetic.AddSigned192(`
30	`469`	`denominator,`
30	`470`	`denominator);`
30	`471`	`Signed320 centerX = WideArithmetic.MultiplySigned192(`
30	`472`	`Signed192.Raw(center.X),`
30	`473`	`axisDenominator);`
30	`474`	`Signed320 centerZ = WideArithmetic.MultiplySigned192(`
30	`475`	`Signed192.Raw(center.Z),`
30	`476`	`axisDenominator);`
30	`477`	`Signed320 offsetX = WideArithmetic.MultiplySigned192(`
30	`478`	`axisX,`
30	`479`	`Signed192.Raw(axisLength));`
30	`480`	`Signed320 offsetZ = WideArithmetic.MultiplySigned192(`
30	`481`	`axisZ,`
30	`482`	`Signed192.Raw(axisLength));`
30	`483`	`first = new RationalPoint(`
30	`484`	`WideArithmetic.SubtractSigned320(centerX, offsetX),`
30	`485`	`WideArithmetic.SubtractSigned320(centerZ, offsetZ));`
30	`486`	`second = new RationalPoint(`
30	`487`	`WideArithmetic.AddSigned320(centerX, offsetX),`
30	`488`	`WideArithmetic.AddSigned320(centerZ, offsetZ));`
30	`489`	`}`
	`490`
	`491`	`private static bool TryGetRadialGap(`
	`492`	`RationalDistance distance,`
	`493`	`Fixed64 shapeRadius,`
	`494`	`Fixed64 maximumGap,`
	`495`	`out Fixed64 gap)`
	`496`	`{`
9	`497`	`Signed192 shapeRaw = Signed192.Raw(shapeRadius);`
9	`498`	`Signed192 maximumRaw = WideArithmetic.AddSigned192(`
9	`499`	`shapeRaw,`
9	`500`	`Signed192.Raw(maximumGap));`
9	`501`	`if (CompareDistanceToRaw(distance, maximumRaw) > 0)`
	`502`	`{`
2	`503`	`gap = default;`
2	`504`	`return false;`
	`505`	`}`
	`506`
7	`507`	`long low = 0L;`
7	`508`	`long high = maximumGap.m_rawValue;`
175	`509`	`while (low < high)`
	`510`	`{`
168	`511`	`long difference = high - low;`
168	`512`	`long middle =`
168	`513`	`low + (difference >> 1) + (difference & 1L);`
168	`514`	`Signed192 candidate = WideArithmetic.AddSigned192(`
168	`515`	`shapeRaw,`
168	`516`	`Signed192.Signed(middle));`
168	`517`	`if (CompareDistanceToRaw(distance, candidate) >= 0)`
151	`518`	`low = middle;`
	`519`	`else`
17	`520`	`high = middle - 1L;`
	`521`	`}`
	`522`
7	`523`	`if (low != maximumGap.m_rawValue)`
	`524`	`{`
3	`525`	`Signed192 midpoint = WideArithmetic.AddSigned192(`
3	`526`	`WideArithmetic.AddSigned192(`
3	`527`	`WideArithmetic.AddSigned192(shapeRaw, shapeRaw),`
3	`528`	`WideArithmetic.AddSigned192(`
3	`529`	`Signed192.Signed(low),`
3	`530`	`Signed192.Signed(low))),`
3	`531`	`Signed192.Signed(1L));`
3	`532`	`int comparison =`
3	`533`	`CompareDistanceToTwiceRaw(distance, midpoint);`
3	`534`	`low += GetHalfToEvenIncrement(comparison, low);`
	`535`	`}`
	`536`
7	`537`	`gap = Fixed64.FromRaw(low);`
7	`538`	`return true;`
	`539`	`}`
	`540`
	`541`	`private static RationalDistance GetPointDistance(`
	`542`	`Vector2d point,`
	`543`	`Signed192 denominator,`
	`544`	`RationalPoint target)`
	`545`	`{`
1081	`546`	`Signed320 x = WideArithmetic.SubtractSigned320(`
1081	`547`	`target.X,`
1081	`548`	`WideArithmetic.MultiplySigned192(`
1081	`549`	`Signed192.Raw(point.X),`
1081	`550`	`denominator));`
1081	`551`	`Signed320 z = WideArithmetic.SubtractSigned320(`
1081	`552`	`target.Z,`
1081	`553`	`WideArithmetic.MultiplySigned192(`
1081	`554`	`Signed192.Raw(point.Y),`
1081	`555`	`denominator));`
1081	`556`	`return new RationalDistance(`
1081	`557`	`Signed576.ExtendValue(x),`
1081	`558`	`Signed576.ExtendValue(z),`
1081	`559`	`Signed576.ExtendValue(`
1081	`560`	`Signed320.ExtendValue(denominator)));`
	`561`	`}`
	`562`
	`563`	`private static RationalDistance GetSegmentDistance(`
	`564`	`Vector2d point,`
	`565`	`Signed192 denominator,`
	`566`	`RationalPoint first,`
	`567`	`RationalPoint second) =>`
2125	`568`	`GetSegmentDistance(`
2125	`569`	`point,`
2125	`570`	`denominator,`
2125	`571`	`first,`
2125	`572`	`second,`
2125	`573`	`out _);`
	`574`
	`575`	`private static RationalDistance GetSegmentDistance(`
	`576`	`Vector2d point,`
	`577`	`Signed192 denominator,`
	`578`	`RationalPoint first,`
	`579`	`RationalPoint second,`
	`580`	`out int feature)`
	`581`	`{`
2141	`582`	`Signed320 firstX = WideArithmetic.SubtractSigned320(`
2141	`583`	`first.X,`
2141	`584`	`WideArithmetic.MultiplySigned192(`
2141	`585`	`Signed192.Raw(point.X),`
2141	`586`	`denominator));`
2141	`587`	`Signed320 firstZ = WideArithmetic.SubtractSigned320(`
2141	`588`	`first.Z,`
2141	`589`	`WideArithmetic.MultiplySigned192(`
2141	`590`	`Signed192.Raw(point.Y),`
2141	`591`	`denominator));`
2141	`592`	`Signed320 edgeX = WideArithmetic.SubtractSigned320(`
2141	`593`	`second.X,`
2141	`594`	`first.X);`
2141	`595`	`Signed320 edgeZ = WideArithmetic.SubtractSigned320(`
2141	`596`	`second.Z,`
2141	`597`	`first.Z);`
2141	`598`	`Signed576 edgeSquared = WideArithmetic.AddSigned576(`
2141	`599`	`WideArithmetic.MultiplySigned320(edgeX, edgeX),`
2141	`600`	`WideArithmetic.MultiplySigned320(edgeZ, edgeZ));`
2141	`601`	`if (edgeSquared.IsZero)`
	`602`	`{`
25	`603`	`feature = -1;`
25	`604`	`return new RationalDistance(`
25	`605`	`Signed576.ExtendValue(firstX),`
25	`606`	`Signed576.ExtendValue(firstZ),`
25	`607`	`Signed576.ExtendValue(`
25	`608`	`Signed320.ExtendValue(denominator)));`
	`609`	`}`
	`610`
2116	`611`	`Signed576 projection = WideArithmetic.SubtractSigned576(`
2116	`612`	`default,`
2116	`613`	`WideArithmetic.AddSigned576(`
2116	`614`	`WideArithmetic.MultiplySigned320(firstX, edgeX),`
2116	`615`	`WideArithmetic.MultiplySigned320(firstZ, edgeZ)));`
2116	`616`	`if (projection.Sign <= 0)`
	`617`	`{`
1058	`618`	`feature = -1;`
1058	`619`	`return new RationalDistance(`
1058	`620`	`Signed576.ExtendValue(firstX),`
1058	`621`	`Signed576.ExtendValue(firstZ),`
1058	`622`	`Signed576.ExtendValue(`
1058	`623`	`Signed320.ExtendValue(denominator)));`
	`624`	`}`
1058	`625`	`if (WideArithmetic.SubtractSigned576(`
1058	`626`	`projection,`
1058	`627`	`edgeSquared).Sign >= 0)`
	`628`	`{`
1044	`629`	`feature = 1;`
1044	`630`	`return GetPointDistance(point, denominator, second);`
	`631`	`}`
	`632`
14	`633`	`feature = 0;`
14	`634`	`Signed576 x = WideArithmetic.AddSigned576(`
14	`635`	`WideArithmetic.MultiplySigned576(`
14	`636`	`edgeSquared,`
14	`637`	`Signed192.NarrowValue(firstX)),`
14	`638`	`WideArithmetic.MultiplySigned576(`
14	`639`	`projection,`
14	`640`	`Signed192.NarrowValue(edgeX)));`
14	`641`	`Signed576 z = WideArithmetic.AddSigned576(`
14	`642`	`WideArithmetic.MultiplySigned576(`
14	`643`	`edgeSquared,`
14	`644`	`Signed192.NarrowValue(firstZ)),`
14	`645`	`WideArithmetic.MultiplySigned576(`
14	`646`	`projection,`
14	`647`	`Signed192.NarrowValue(edgeZ)));`
14	`648`	`Signed576 combinedDenominator =`
14	`649`	`WideArithmetic.MultiplySigned576(`
14	`650`	`edgeSquared,`
14	`651`	`denominator);`
14	`652`	`return new RationalDistance(x, z, combinedDenominator);`
	`653`	`}`
	`654`
	`655`	`private static bool IsWithinRadius(`
	`656`	`RationalDistance distance,`
	`657`	`Fixed64 radius)`
	`658`	`{`
8	`659`	`Signed576 scaledRadius = WideArithmetic.MultiplySigned576(`
8	`660`	`distance.Denominator,`
8	`661`	`Signed192.Raw(radius));`
8	`662`	`Signed832 squaredRadius =`
8	`663`	`WideArithmetic.MultiplySigned576ToSigned832(`
8	`664`	`scaledRadius,`
8	`665`	`scaledRadius);`
8	`666`	`return WideArithmetic.SubtractSigned832(`
8	`667`	`distance.SquaredDistance,`
8	`668`	`squaredRadius).Sign <= 0;`
	`669`	`}`
	`670`
	`671`	`private static bool TryGetDistance(`
	`672`	`RationalDistance distance,`
	`673`	`Fixed64 maximum,`
	`674`	`out Fixed64 result)`
	`675`	`{`
8	`676`	`if (!IsWithinRadius(distance, maximum))`
	`677`	`{`
2	`678`	`result = default;`
2	`679`	`return false;`
	`680`	`}`
	`681`
6	`682`	`long low = 0L;`
6	`683`	`long high = maximum.m_rawValue;`
203	`684`	`while (low < high)`
	`685`	`{`
197	`686`	`long difference = high - low;`
197	`687`	`long middle =`
197	`688`	`low + (difference >> 1) + (difference & 1L);`
197	`689`	`if (CompareDistanceToRaw(distance, middle) >= 0)`
165	`690`	`low = middle;`
	`691`	`else`
32	`692`	`high = middle - 1L;`
	`693`	`}`
	`694`
6	`695`	`if (low != maximum.m_rawValue)`
	`696`	`{`
2	`697`	`long doubledLow = low + low;`
2	`698`	`int midpointComparison =`
2	`699`	`CompareDistanceToTwiceRaw(`
2	`700`	`distance,`
2	`701`	`doubledLow + 1L);`
2	`702`	`low += GetHalfToEvenIncrement(midpointComparison, low);`
	`703`	`}`
	`704`
6	`705`	`result = Fixed64.FromRaw(low);`
6	`706`	`return true;`
	`707`	`}`
	`708`
	`709`	`private static int CompareDistanceToRaw(`
	`710`	`RationalDistance distance,`
	`711`	`long raw) =>`
197	`712`	`CompareDistanceToRaw(`
197	`713`	`distance,`
197	`714`	`Signed192.Signed(raw));`
	`715`
	`716`	`private static int CompareDistanceToRaw(`
	`717`	`RationalDistance distance,`
	`718`	`Signed192 raw)`
	`719`	`{`
2540	`720`	`Signed576 scaled = WideArithmetic.MultiplySigned576(`
2540	`721`	`distance.Denominator,`
2540	`722`	`raw);`
2540	`723`	`Signed832 squared = WideArithmetic.MultiplySigned576ToSigned832(`
2540	`724`	`scaled,`
2540	`725`	`scaled);`
2540	`726`	`return WideArithmetic.SubtractSigned832(`
2540	`727`	`distance.SquaredDistance,`
2540	`728`	`squared).Sign;`
	`729`	`}`
	`730`
	`731`	`private static int CompareDistanceToTwiceRaw(`
	`732`	`RationalDistance distance,`
	`733`	`long twiceRaw) =>`
2	`734`	`CompareDistanceToTwiceRaw(`
2	`735`	`distance,`
2	`736`	`Signed192.Signed(twiceRaw));`
	`737`
	`738`	`private static int CompareDistanceToTwiceRaw(`
	`739`	`RationalDistance distance,`
	`740`	`Signed192 twiceRaw)`
	`741`	`{`
20	`742`	`Signed832 fourDistance = WideArithmetic.AddSigned832(`
20	`743`	`WideArithmetic.AddSigned832(`
20	`744`	`distance.SquaredDistance,`
20	`745`	`distance.SquaredDistance),`
20	`746`	`WideArithmetic.AddSigned832(`
20	`747`	`distance.SquaredDistance,`
20	`748`	`distance.SquaredDistance));`
20	`749`	`Signed576 scaled = WideArithmetic.MultiplySigned576(`
20	`750`	`distance.Denominator,`
20	`751`	`twiceRaw);`
20	`752`	`Signed832 squared = WideArithmetic.MultiplySigned576ToSigned832(`
20	`753`	`scaled,`
20	`754`	`scaled);`
20	`755`	`return WideArithmetic.SubtractSigned832(`
20	`756`	`fourDistance,`
20	`757`	`squared).Sign;`
	`758`	`}`
	`759`
	`760`	`private static Vector2d GetOffset(RationalDistance distance)`
	`761`	`{`
6	`762`	`_ = Fixed64.TryGetSignedRawRatio(`
6	`763`	`distance.X,`
6	`764`	`distance.Denominator,`
6	`765`	`out Fixed64 x);`
6	`766`	`_ = Fixed64.TryGetSignedRawRatio(`
6	`767`	`distance.Z,`
6	`768`	`distance.Denominator,`
6	`769`	`out Fixed64 z);`
6	`770`	`return new Vector2d(x, z);`
	`771`	`}`
	`772`
	`773`	`private static long GetHalfToEvenIncrement(`
	`774`	`int midpointComparison,`
	`775`	`long lowerRaw)`
	`776`	`{`
5	`777`	`int negative = (int)((uint)midpointComparison >> 31);`
5	`778`	`int nonzero = (int)(`
5	`779`	`(uint)(midpointComparison \| -midpointComparison) >> 31);`
5	`780`	`int positive = nonzero & (negative ^ 1);`
5	`781`	`int zero = nonzero ^ 1;`
5	`782`	`return (long)positive \| ((long)zero & (lowerRaw & 1L));`
	`783`	`}`
	`784`
	`785`	`private static Signed320 GetLargestPositiveMagnitude(`
	`786`	`Signed320 first,`
	`787`	`Signed320 second,`
	`788`	`Signed320 third,`
	`789`	`Signed320 fourth,`
	`790`	`Signed320 fifth)`
	`791`	`{`
16	`792`	`Signed320 largest =`
16	`793`	`WideArithmetic.CompareMagnitude(first, second) >= 0`
16	`794`	`? first`
16	`795`	`: second;`
16	`796`	`if (WideArithmetic.CompareMagnitude(largest, third) < 0)`
4	`797`	`largest = third;`
16	`798`	`if (WideArithmetic.CompareMagnitude(largest, fourth) < 0)`
4	`799`	`largest = fourth;`
16	`800`	`if (WideArithmetic.CompareMagnitude(largest, fifth) < 0)`
2	`801`	`largest = fifth;`
16	`802`	`return largest.Sign < 0`
16	`803`	`? WideArithmetic.SubtractSigned320(default, largest)`
16	`804`	`: largest;`
	`805`	`}`
	`806`	`}`

/home/runner/work/FixedMathSharp/FixedMathSharp/src/FixedMathSharp/Geometry/Wide/Common/WidePlanarProjection.Disk.cs

#	Line	Line coverage
	`1`	`//=======================================================================`
	`2`	`// WidePlanarProjection.Disk.cs`
	`3`	`//=======================================================================`
	`4`	`// MIT License, Copyright (c) 2024-present David Oravsky (mrdav30)`
	`5`	`// See LICENSE file in the project root for full license information.`
	`6`	`//=======================================================================`
	`7`
	`8`	`using System;`
	`9`
	`10`	`namespace FixedMathSharp.Geometry;`
	`11`
	`12`	`/// <content>`
	`13`	`/// Exact projected-disk admission and correctly rounded planar distance.`
	`14`	`/// </content>`
	`15`	`internal static partial class WidePlanarProjection`
	`16`	`{`
	`17`	`private static bool TryGetProjectedDiskRelation(`
	`18`	`Vector2d circleCenter,`
	`19`	`Fixed64 circleRadius,`
	`20`	`RationalPoint diskCenter,`
	`21`	`Signed192 coordinateDenominator,`
	`22`	`Signed192 axisX,`
	`23`	`Signed192 axisY,`
	`24`	`Signed192 axisZ,`
	`25`	`Fixed64 diskRadius,`
	`26`	`out PlanarProjectionRelation relation)`
	`27`	`{`
14	`28`	`if (axisY.IsZero)`
	`29`	`{`
1	`30`	`GetProjectedDiskSegmentEndpoints(`
1	`31`	`diskCenter,`
1	`32`	`axisX,`
1	`33`	`axisZ,`
1	`34`	`diskRadius,`
1	`35`	`out RationalPoint first,`
1	`36`	`out RationalPoint second);`
1	`37`	`return TryCreateRelation(`
1	`38`	`GetSegmentDistance(`
1	`39`	`circleCenter,`
1	`40`	`coordinateDenominator,`
1	`41`	`first,`
1	`42`	`second),`
1	`43`	`circleRadius,`
1	`44`	`out relation);`
	`45`	`}`
	`46`
13	`47`	`RationalDistance centerDistance = GetPointDistance(`
13	`48`	`circleCenter,`
13	`49`	`coordinateDenominator,`
13	`50`	`diskCenter);`
13	`51`	`if (axisX.IsZero && axisZ.IsZero)`
	`52`	`{`
2	`53`	`return TryCreateRadiallyExpandedRelation(`
2	`54`	`centerDistance,`
2	`55`	`diskRadius,`
2	`56`	`circleRadius,`
2	`57`	`out relation);`
	`58`	`}`
	`59`
11	`60`	`int maximumComparison = CompareProjectedDiskDistanceToRadius(`
11	`61`	`centerDistance,`
11	`62`	`coordinateDenominator,`
11	`63`	`axisX,`
11	`64`	`axisY,`
11	`65`	`axisZ,`
11	`66`	`diskRadius,`
11	`67`	`Signed192.Raw(circleRadius),`
11	`68`	`radiusDenominator: 1);`
11	`69`	`if (maximumComparison > 0)`
	`70`	`{`
1	`71`	`relation = default;`
1	`72`	`return false;`
	`73`	`}`
	`74`
10	`75`	`int zeroComparison = CompareProjectedDiskDistanceToRadius(`
10	`76`	`centerDistance,`
10	`77`	`coordinateDenominator,`
10	`78`	`axisX,`
10	`79`	`axisY,`
10	`80`	`axisZ,`
10	`81`	`diskRadius,`
10	`82`	`default,`
10	`83`	`radiusDenominator: 1);`
10	`84`	`if (zeroComparison <= 0)`
	`85`	`{`
2	`86`	`relation = PlanarProjectionRelation.Contained;`
2	`87`	`return true;`
	`88`	`}`
	`89`
8	`90`	`GetProjectedDiskClosestOffset(`
8	`91`	`centerDistance,`
8	`92`	`coordinateDenominator,`
8	`93`	`axisX,`
8	`94`	`axisY,`
8	`95`	`axisZ,`
8	`96`	`diskRadius,`
8	`97`	`out Fixed64 approximateDistance,`
8	`98`	`out Vector2d direction);`
8	`99`	`long low = GetProjectedDiskCeilingDistance(`
8	`100`	`centerDistance,`
8	`101`	`coordinateDenominator,`
8	`102`	`axisX,`
8	`103`	`axisY,`
8	`104`	`axisZ,`
8	`105`	`diskRadius,`
8	`106`	`circleRadius,`
8	`107`	`approximateDistance);`
	`108`
8	`109`	`long floor = low - 1L;`
8	`110`	`Signed192 midpointNumerator = WideArithmetic.AddSigned192(`
8	`111`	`WideArithmetic.AddSigned192(`
8	`112`	`Signed192.Signed(floor),`
8	`113`	`Signed192.Signed(floor)),`
8	`114`	`Signed192.Signed(1L));`
8	`115`	`int midpointComparison = CompareProjectedDiskDistanceToRadius(`
8	`116`	`centerDistance,`
8	`117`	`coordinateDenominator,`
8	`118`	`axisX,`
8	`119`	`axisY,`
8	`120`	`axisZ,`
8	`121`	`diskRadius,`
8	`122`	`midpointNumerator,`
8	`123`	`radiusDenominator: 2);`
8	`124`	`long rounded = midpointComparison < 0`
8	`125`	`? floor`
8	`126`	`: midpointComparison > 0`
8	`127`	`? low`
8	`128`	`: floor + (floor & 1L);`
8	`129`	`Fixed64 distance = Fixed64.FromRaw(rounded);`
8	`130`	`relation = new PlanarProjectionRelation(`
8	`131`	`distance,`
8	`132`	`direction * distance,`
8	`133`	`direction);`
8	`134`	`return true;`
	`135`	`}`
	`136`
	`137`	`private static long GetProjectedDiskCeilingDistance(`
	`138`	`RationalDistance centerDistance,`
	`139`	`Signed192 coordinateDenominator,`
	`140`	`Signed192 axisX,`
	`141`	`Signed192 axisY,`
	`142`	`Signed192 axisZ,`
	`143`	`Fixed64 diskRadius,`
	`144`	`Fixed64 maximum,`
	`145`	`Fixed64 approximate)`
	`146`	`{`
8	`147`	`long candidate = approximate.m_rawValue;`
8	`148`	`if (candidate > maximum.m_rawValue)`
2	`149`	`candidate = maximum.m_rawValue;`
	`150`
8	`151`	`int comparison = CompareProjectedDiskDistanceToRadius(`
8	`152`	`centerDistance,`
8	`153`	`coordinateDenominator,`
8	`154`	`axisX,`
8	`155`	`axisY,`
8	`156`	`axisZ,`
8	`157`	`diskRadius,`
8	`158`	`Signed192.Signed(candidate),`
8	`159`	`radiusDenominator: 1);`
8	`160`	`if (comparison <= 0)`
	`161`	`{`
4	`162`	`long high = candidate;`
4	`163`	`long step = 1L;`
14	`164`	`while (high > 1L)`
	`165`	`{`
12	`166`	`long probe = high > step ? high - step : 0L;`
12	`167`	`if (probe == 0L`
12	`168`	`\|\| CompareProjectedDiskDistanceToRadius(`
12	`169`	`centerDistance,`
12	`170`	`coordinateDenominator,`
12	`171`	`axisX,`
12	`172`	`axisY,`
12	`173`	`axisZ,`
12	`174`	`diskRadius,`
12	`175`	`Signed192.Signed(probe),`
12	`176`	`radiusDenominator: 1) > 0)`
	`177`	`{`
2	`178`	`return FindProjectedDiskCeilingDistance(`
2	`179`	`centerDistance,`
2	`180`	`coordinateDenominator,`
2	`181`	`axisX,`
2	`182`	`axisY,`
2	`183`	`axisZ,`
2	`184`	`diskRadius,`
2	`185`	`probe + 1L,`
2	`186`	`high);`
	`187`	`}`
	`188`
10	`189`	`high = probe;`
10	`190`	`step = (long)Math.Min(`
10	`191`	`(ulong)step << 1,`
10	`192`	`(ulong)high);`
	`193`	`}`
	`194`
2	`195`	`return 1L;`
	`196`	`}`
	`197`
4	`198`	`long low = candidate + 1L;`
4	`199`	`long upper = maximum.m_rawValue;`
4	`200`	`long upwardStep = 1L;`
6	`201`	`while (low < upper)`
	`202`	`{`
3	`203`	`long remaining = upper - candidate;`
3	`204`	`long probe = candidate + Math.Min(`
3	`205`	`upwardStep,`
3	`206`	`remaining);`
3	`207`	`if (CompareProjectedDiskDistanceToRadius(`
3	`208`	`centerDistance,`
3	`209`	`coordinateDenominator,`
3	`210`	`axisX,`
3	`211`	`axisY,`
3	`212`	`axisZ,`
3	`213`	`diskRadius,`
3	`214`	`Signed192.Signed(probe),`
3	`215`	`radiusDenominator: 1) <= 0)`
	`216`	`{`
1	`217`	`return FindProjectedDiskCeilingDistance(`
1	`218`	`centerDistance,`
1	`219`	`coordinateDenominator,`
1	`220`	`axisX,`
1	`221`	`axisY,`
1	`222`	`axisZ,`
1	`223`	`diskRadius,`
1	`224`	`low,`
1	`225`	`probe);`
	`226`	`}`
	`227`
2	`228`	`low = probe + 1L;`
2	`229`	`upwardStep = (long)Math.Min(`
2	`230`	`(ulong)upwardStep << 1,`
2	`231`	`(ulong)(upper - candidate));`
	`232`	`}`
	`233`
3	`234`	`return upper;`
	`235`	`}`
	`236`
	`237`	`private static long FindProjectedDiskCeilingDistance(`
	`238`	`RationalDistance centerDistance,`
	`239`	`Signed192 coordinateDenominator,`
	`240`	`Signed192 axisX,`
	`241`	`Signed192 axisY,`
	`242`	`Signed192 axisZ,`
	`243`	`Fixed64 diskRadius,`
	`244`	`long low,`
	`245`	`long high)`
	`246`	`{`
13	`247`	`while (low < high)`
	`248`	`{`
10	`249`	`long middle = low + ((high - low) >> 1);`
10	`250`	`int comparison = CompareProjectedDiskDistanceToRadius(`
10	`251`	`centerDistance,`
10	`252`	`coordinateDenominator,`
10	`253`	`axisX,`
10	`254`	`axisY,`
10	`255`	`axisZ,`
10	`256`	`diskRadius,`
10	`257`	`Signed192.Signed(middle),`
10	`258`	`radiusDenominator: 1);`
10	`259`	`if (comparison <= 0)`
5	`260`	`high = middle;`
	`261`	`else`
5	`262`	`low = middle + 1L;`
	`263`	`}`
	`264`
3	`265`	`return low;`
	`266`	`}`
	`267`
	`268`	`private static void GetProjectedDiskClosestOffset(`
	`269`	`RationalDistance centerDistance,`
	`270`	`Signed192 coordinateDenominator,`
	`271`	`Signed192 axisX,`
	`272`	`Signed192 axisY,`
	`273`	`Signed192 axisZ,`
	`274`	`Fixed64 diskRadius,`
	`275`	`out Fixed64 approximateDistance,`
	`276`	`out Vector2d direction)`
	`277`	`{`
8	`278`	`Signed320 relativeX = Signed320.NarrowValue(centerDistance.X);`
8	`279`	`Signed320 relativeZ = Signed320.NarrowValue(centerDistance.Z);`
8	`280`	`Signed320 scaledRadius = WideArithmetic.MultiplySigned192(`
8	`281`	`coordinateDenominator,`
8	`282`	`Signed192.Raw(diskRadius));`
8	`283`	`Signed320 scale = GetLargestPositiveMagnitude(`
8	`284`	`relativeX,`
8	`285`	`relativeZ,`
8	`286`	`default,`
8	`287`	`scaledRadius,`
8	`288`	`default);`
8	`289`	`Fixed64 queryX = -Fixed64.GetSignedRatio(relativeX, scale);`
8	`290`	`Fixed64 queryZ = -Fixed64.GetSignedRatio(relativeZ, scale);`
8	`291`	`Fixed64 radius = Fixed64.GetSignedRatio(scaledRadius, scale);`
8	`292`	`Vector2d axis = WideNormalization.GetNormalized(axisX, axisZ);`
8	`293`	`Vector2d perpendicular = new(-axis.Y, axis.X);`
8	`294`	`Fixed64 along = Vector2d.Dot(new Vector2d(queryX, queryZ), axis);`
8	`295`	`Fixed64 across = Vector2d.Dot(`
8	`296`	`new Vector2d(queryX, queryZ),`
8	`297`	`perpendicular);`
8	`298`	`Fixed64 axisYRatio = FixedMath.Abs(`
8	`299`	`WideNormalization.GetNormalized(`
8	`300`	`axisX,`
8	`301`	`axisY,`
8	`302`	`axisZ).Y);`
8	`303`	`Fixed64 minor = radius * axisYRatio;`
8	`304`	`Vector2d localOffset = GetEllipseClosestOffset(`
8	`305`	`along,`
8	`306`	`across,`
8	`307`	`minor,`
8	`308`	`radius);`
8	`309`	`Vector2d worldOffset =`
8	`310`	`axis * localOffset.X + perpendicular * localOffset.Y;`
8	`311`	`direction = worldOffset.Normalized;`
	`312`
8	`313`	`Signed576 distanceNumerator =`
8	`314`	`WideArithmetic.MultiplySigned320(`
8	`315`	`scale,`
8	`316`	`Signed320.ExtendValue(`
8	`317`	`Signed192.Raw(worldOffset.Magnitude)));`
8	`318`	`_ = Fixed64.TryGetSignedRawRatio(`
8	`319`	`distanceNumerator,`
8	`320`	`Signed576.ExtendValue(`
8	`321`	`WideArithmetic.MultiplySigned192(`
8	`322`	`coordinateDenominator,`
8	`323`	`Signed192.Raw(Fixed64.One))),`
8	`324`	`out approximateDistance);`
8	`325`	`}`
	`326`
	`327`	`private static Vector2d GetEllipseClosestOffset(`
	`328`	`Fixed64 queryX,`
	`329`	`Fixed64 queryY,`
	`330`	`Fixed64 radiusX,`
	`331`	`Fixed64 radiusY)`
	`332`	`{`
16	`333`	`Fixed64 radiusXSquared = radiusX * radiusX;`
16	`334`	`Fixed64 radiusYSquared = radiusY * radiusY;`
16	`335`	`Fixed64 low = Fixed64.Zero;`
16	`336`	`Fixed64 high = Fixed64.Two;`
544	`337`	`while (high.m_rawValue - low.m_rawValue > 1L)`
	`338`	`{`
528	`339`	`Fixed64 middle = Fixed64.FromRaw(`
528	`340`	`low.m_rawValue`
528	`341`	`+ ((high.m_rawValue - low.m_rawValue) >> 1));`
528	`342`	`Fixed64 x = GetEllipseConstraintCoordinate(`
528	`343`	`radiusX,`
528	`344`	`queryX,`
528	`345`	`middle + radiusXSquared);`
528	`346`	`Fixed64 y = GetEllipseConstraintCoordinate(`
528	`347`	`radiusY,`
528	`348`	`queryY,`
528	`349`	`middle + radiusYSquared);`
528	`350`	`if (x * x + y * y > Fixed64.One)`
185	`351`	`low = middle;`
	`352`	`else`
343	`353`	`high = middle;`
	`354`	`}`
	`355`
16	`356`	`Fixed64 closestX = Fixed64.MultiplyDivide(`
16	`357`	`radiusXSquared,`
16	`358`	`queryX,`
16	`359`	`high + radiusXSquared,`
16	`360`	`out _);`
16	`361`	`Fixed64 closestY = Fixed64.MultiplyDivide(`
16	`362`	`radiusYSquared,`
16	`363`	`queryY,`
16	`364`	`high + radiusYSquared,`
16	`365`	`out _);`
16	`366`	`return new Vector2d(`
16	`367`	`closestX - queryX,`
16	`368`	`closestY - queryY);`
	`369`	`}`
	`370`
	`371`	`private static Fixed64 GetEllipseConstraintCoordinate(`
	`372`	`Fixed64 radius,`
	`373`	`Fixed64 query,`
	`374`	`Fixed64 denominator) =>`
1056	`375`	`Fixed64.MultiplyDivide(`
1056	`376`	`radius,`
1056	`377`	`query,`
1056	`378`	`denominator,`
1056	`379`	`out _);`
	`380`
	`381`	`private static void GetProjectedDiskSegmentEndpoints(`
	`382`	`RationalPoint diskCenter,`
	`383`	`Signed192 axisX,`
	`384`	`Signed192 axisZ,`
	`385`	`Fixed64 diskRadius,`
	`386`	`out RationalPoint first,`
	`387`	`out RationalPoint second)`
	`388`	`{`
2	`389`	`Signed192 scaledRadius = WideArithmetic.AddSigned192(`
2	`390`	`Signed192.Raw(diskRadius),`
2	`391`	`Signed192.Raw(diskRadius));`
	`392`
2	`393`	`Signed320 offsetX = WideArithmetic.MultiplySigned192(`
2	`394`	`WideArithmetic.SubtractSigned192(`
2	`395`	`default,`
2	`396`	`axisZ),`
2	`397`	`scaledRadius);`
2	`398`	`Signed320 offsetZ = WideArithmetic.MultiplySigned192(`
2	`399`	`axisX,`
2	`400`	`scaledRadius);`
2	`401`	`first = new RationalPoint(`
2	`402`	`WideArithmetic.AddSigned320(`
2	`403`	`diskCenter.X,`
2	`404`	`offsetX),`
2	`405`	`WideArithmetic.AddSigned320(`
2	`406`	`diskCenter.Z,`
2	`407`	`offsetZ));`
2	`408`	`second = new RationalPoint(`
2	`409`	`WideArithmetic.SubtractSigned320(`
2	`410`	`diskCenter.X,`
2	`411`	`offsetX),`
2	`412`	`WideArithmetic.SubtractSigned320(`
2	`413`	`diskCenter.Z,`
2	`414`	`offsetZ));`
2	`415`	`}`
	`416`
	`417`	`private static int CompareProjectedDiskDistanceToRadius(`
	`418`	`RationalDistance centerDistance,`
	`419`	`Signed192 coordinateDenominator,`
	`420`	`Signed192 axisX,`
	`421`	`Signed192 axisY,`
	`422`	`Signed192 axisZ,`
	`423`	`Fixed64 diskRadius,`
	`424`	`Signed192 radiusNumerator,`
	`425`	`int radiusDenominator)`
	`426`	`{`
132	`427`	`Signed320 relativeX = Signed320.NarrowValue(`
132	`428`	`centerDistance.X);`
132	`429`	`Signed320 relativeZ = Signed320.NarrowValue(`
132	`430`	`centerDistance.Z);`
132	`431`	`int centerSign = EvaluateProjectedDiskConic(`
132	`432`	`relativeX,`
132	`433`	`relativeZ,`
132	`434`	`coordinateDenominator,`
132	`435`	`axisX,`
132	`436`	`axisY,`
132	`437`	`axisZ,`
132	`438`	`diskRadius);`
132	`439`	`if (centerSign <= 0)`
4	`440`	`return radiusNumerator.IsZero ? 0 : -1;`
128	`441`	`if (radiusNumerator.IsZero)`
20	`442`	`return 1;`
	`443`
108	`444`	`int rootCount = CountProjectedDiskCircleRoots(`
108	`445`	`relativeX,`
108	`446`	`relativeZ,`
108	`447`	`coordinateDenominator,`
108	`448`	`axisX,`
108	`449`	`axisY,`
108	`450`	`axisZ,`
108	`451`	`diskRadius,`
108	`452`	`radiusNumerator,`
108	`453`	`radiusDenominator);`
108	`454`	`if (rootCount != 0)`
55	`455`	`return rootCount == 1 ? 0 : -1;`
	`456`
53	`457`	`int centerDistanceComparison = radiusDenominator == 1`
53	`458`	`? CompareDistanceToRaw(`
53	`459`	`centerDistance,`
53	`460`	`radiusNumerator)`
53	`461`	`: CompareDistanceToTwiceRaw(`
53	`462`	`centerDistance,`
53	`463`	`radiusNumerator);`
53	`464`	`return centerDistanceComparison <= 0 ? -1 : 1;`
	`465`	`}`
	`466`
	`467`	`private static int CountProjectedDiskCircleRoots(`
	`468`	`Signed320 relativeX,`
	`469`	`Signed320 relativeZ,`
	`470`	`Signed192 coordinateDenominator,`
	`471`	`Signed192 axisX,`
	`472`	`Signed192 axisY,`
	`473`	`Signed192 axisZ,`
	`474`	`Fixed64 diskRadius,`
	`475`	`Signed192 radiusNumerator,`
	`476`	`int radiusDenominator)`
	`477`	`{`
108	`478`	`CreateProjectedDiskCirclePolynomial(`
108	`479`	`relativeX,`
108	`480`	`relativeZ,`
108	`481`	`coordinateDenominator,`
108	`482`	`axisX,`
108	`483`	`axisY,`
108	`484`	`axisZ,`
108	`485`	`diskRadius,`
108	`486`	`radiusNumerator,`
108	`487`	`radiusDenominator,`
108	`488`	`1,`
108	`489`	`0,`
108	`490`	`out Signed832 constant,`
108	`491`	`out Signed832 linear,`
108	`492`	`out Signed832 quadratic,`
108	`493`	`out Signed832 cubic,`
108	`494`	`out Signed832 quartic);`
108	`495`	`if (quartic.Sign == 0)`
	`496`	`{`
1	`497`	`CreateProjectedDiskCirclePolynomial(`
1	`498`	`relativeX,`
1	`499`	`relativeZ,`
1	`500`	`coordinateDenominator,`
1	`501`	`axisX,`
1	`502`	`axisY,`
1	`503`	`axisZ,`
1	`504`	`diskRadius,`
1	`505`	`radiusNumerator,`
1	`506`	`radiusDenominator,`
1	`507`	`-1,`
1	`508`	`0,`
1	`509`	`out constant,`
1	`510`	`out linear,`
1	`511`	`out quadratic,`
1	`512`	`out cubic,`
1	`513`	`out quartic);`
	`514`	`}`
	`515`
108	`516`	`return WideFiniteAxisIntersection.CountProjectionDomainQuarticRoots(`
108	`517`	`constant,`
108	`518`	`linear,`
108	`519`	`quadratic,`
108	`520`	`cubic,`
108	`521`	`quartic);`
	`522`	`}`
	`523`
	`524`	`private static void CreateProjectedDiskCirclePolynomial(`
	`525`	`Signed320 relativeX,`
	`526`	`Signed320 relativeZ,`
	`527`	`Signed192 coordinateDenominator,`
	`528`	`Signed192 axisX,`
	`529`	`Signed192 axisY,`
	`530`	`Signed192 axisZ,`
	`531`	`Fixed64 diskRadius,`
	`532`	`Signed192 radiusNumerator,`
	`533`	`int radiusDenominator,`
	`534`	`int directionX,`
	`535`	`int directionZ,`
	`536`	`out Signed832 constant,`
	`537`	`out Signed832 linear,`
	`538`	`out Signed832 quadratic,`
	`539`	`out Signed832 cubic,`
	`540`	`out Signed832 quartic)`
	`541`	`{`
109	`542`	`Signed320 radiusScale = WideArithmetic.MultiplySigned192(`
109	`543`	`radiusNumerator,`
109	`544`	`coordinateDenominator);`
109	`545`	`Signed320 scaledX = MultiplyBySmall(`
109	`546`	`relativeX,`
109	`547`	`radiusDenominator);`
109	`548`	`Signed320 scaledZ = MultiplyBySmall(`
109	`549`	`relativeZ,`
109	`550`	`radiusDenominator);`
109	`551`	`Signed320 radialX = MultiplyBySmall(`
109	`552`	`radiusScale,`
109	`553`	`directionX);`
109	`554`	`Signed320 radialZ = MultiplyBySmall(`
109	`555`	`radiusScale,`
109	`556`	`directionZ);`
109	`557`	`Signed320 perpendicularX = MultiplyBySmall(`
109	`558`	`radiusScale,`
109	`559`	`-directionZ * 2);`
109	`560`	`Signed320 perpendicularZ = MultiplyBySmall(`
109	`561`	`radiusScale,`
109	`562`	`directionX * 2);`
109	`563`	`Signed320 x0 = WideArithmetic.AddSigned320(`
109	`564`	`scaledX,`
109	`565`	`radialX);`
109	`566`	`Signed320 x1 = perpendicularX;`
109	`567`	`Signed320 x2 = WideArithmetic.SubtractSigned320(`
109	`568`	`scaledX,`
109	`569`	`radialX);`
109	`570`	`Signed320 z0 = WideArithmetic.AddSigned320(`
109	`571`	`scaledZ,`
109	`572`	`radialZ);`
109	`573`	`Signed320 z1 = perpendicularZ;`
109	`574`	`Signed320 z2 = WideArithmetic.SubtractSigned320(`
109	`575`	`scaledZ,`
109	`576`	`radialZ);`
	`577`
109	`578`	`Signed320 axisY2 = WideArithmetic.MultiplySigned192(`
109	`579`	`axisY,`
109	`580`	`axisY);`
109	`581`	`GetSquaredPolynomial(`
109	`582`	`x0,`
109	`583`	`x1,`
109	`584`	`x2,`
109	`585`	`out Signed576 xSquared0,`
109	`586`	`out Signed576 xSquared1,`
109	`587`	`out Signed576 xSquared2,`
109	`588`	`out Signed576 xSquared3,`
109	`589`	`out Signed576 xSquared4);`
109	`590`	`GetSquaredPolynomial(`
109	`591`	`z0,`
109	`592`	`z1,`
109	`593`	`z2,`
109	`594`	`out Signed576 zSquared0,`
109	`595`	`out Signed576 zSquared1,`
109	`596`	`out Signed576 zSquared2,`
109	`597`	`out Signed576 zSquared3,`
109	`598`	`out Signed576 zSquared4);`
109	`599`	`Signed576 dot0 = WideArithmetic.AddSigned576(`
109	`600`	`WideArithmetic.MultiplySigned320(`
109	`601`	`x0,`
109	`602`	`Signed320.ExtendValue(axisX)),`
109	`603`	`WideArithmetic.MultiplySigned320(`
109	`604`	`z0,`
109	`605`	`Signed320.ExtendValue(axisZ)));`
109	`606`	`Signed576 dot1 = WideArithmetic.AddSigned576(`
109	`607`	`WideArithmetic.MultiplySigned320(`
109	`608`	`x1,`
109	`609`	`Signed320.ExtendValue(axisX)),`
109	`610`	`WideArithmetic.MultiplySigned320(`
109	`611`	`z1,`
109	`612`	`Signed320.ExtendValue(axisZ)));`
109	`613`	`Signed576 dot2 = WideArithmetic.AddSigned576(`
109	`614`	`WideArithmetic.MultiplySigned320(`
109	`615`	`x2,`
109	`616`	`Signed320.ExtendValue(axisX)),`
109	`617`	`WideArithmetic.MultiplySigned320(`
109	`618`	`z2,`
109	`619`	`Signed320.ExtendValue(axisZ)));`
	`620`
109	`621`	`Signed192 commonDenominator = coordinateDenominator;`
109	`622`	`if (radiusDenominator == 2)`
	`623`	`{`
16	`624`	`commonDenominator = WideArithmetic.AddSigned192(`
16	`625`	`commonDenominator,`
16	`626`	`commonDenominator);`
	`627`	`}`
109	`628`	`Signed320 diskRadiusSquared = WideArithmetic.MultiplySigned192(`
109	`629`	`Signed192.Raw(diskRadius),`
109	`630`	`Signed192.Raw(diskRadius));`
109	`631`	`Signed576 diskAndAxis = WideArithmetic.MultiplySigned320(`
109	`632`	`diskRadiusSquared,`
109	`633`	`axisY2);`
109	`634`	`Signed320 denominatorSquared =`
109	`635`	`WideArithmetic.MultiplySigned192(`
109	`636`	`commonDenominator,`
109	`637`	`commonDenominator);`
109	`638`	`Signed832 limit =`
109	`639`	`WideArithmetic.MultiplySigned576ToSigned832(`
109	`640`	`diskAndAxis,`
109	`641`	`denominatorSquared);`
	`642`
109	`643`	`constant = WideArithmetic.SubtractSigned832(`
109	`644`	`GetProjectedDiskConicCoefficient(`
109	`645`	`xSquared0,`
109	`646`	`zSquared0,`
109	`647`	`axisY2,`
109	`648`	`dot0,`
109	`649`	`dot0),`
109	`650`	`limit);`
109	`651`	`linear = WideArithmetic.AddSigned832(`
109	`652`	`GetProjectedDiskRadialCoefficient(`
109	`653`	`xSquared1,`
109	`654`	`zSquared1,`
109	`655`	`axisY2),`
109	`656`	`DoubleSigned832(`
109	`657`	`WideArithmetic.MultiplySigned576ToSigned832(`
109	`658`	`dot0,`
109	`659`	`dot1)));`
109	`660`	`quadratic = WideArithmetic.AddSigned832(`
109	`661`	`GetProjectedDiskConicCoefficient(`
109	`662`	`xSquared2,`
109	`663`	`zSquared2,`
109	`664`	`axisY2,`
109	`665`	`dot1,`
109	`666`	`dot1),`
109	`667`	`DoubleSigned832(`
109	`668`	`WideArithmetic.MultiplySigned576ToSigned832(`
109	`669`	`dot0,`
109	`670`	`dot2)));`
109	`671`	`quadratic = WideArithmetic.SubtractSigned832(`
109	`672`	`quadratic,`
109	`673`	`DoubleSigned832(limit));`
109	`674`	`cubic = WideArithmetic.AddSigned832(`
109	`675`	`GetProjectedDiskRadialCoefficient(`
109	`676`	`xSquared3,`
109	`677`	`zSquared3,`
109	`678`	`axisY2),`
109	`679`	`DoubleSigned832(`
109	`680`	`WideArithmetic.MultiplySigned576ToSigned832(`
109	`681`	`dot1,`
109	`682`	`dot2)));`
109	`683`	`quartic = WideArithmetic.SubtractSigned832(`
109	`684`	`GetProjectedDiskConicCoefficient(`
109	`685`	`xSquared4,`
109	`686`	`zSquared4,`
109	`687`	`axisY2,`
109	`688`	`dot2,`
109	`689`	`dot2),`
109	`690`	`limit);`
109	`691`	`}`
	`692`
	`693`	`private static Signed832 GetProjectedDiskConicCoefficient(`
	`694`	`Signed576 xSquared,`
	`695`	`Signed576 zSquared,`
	`696`	`Signed320 axisYSquared,`
	`697`	`Signed576 firstDot,`
	`698`	`Signed576 secondDot) =>`
327	`699`	`WideArithmetic.AddSigned832(`
327	`700`	`GetProjectedDiskRadialCoefficient(`
327	`701`	`xSquared,`
327	`702`	`zSquared,`
327	`703`	`axisYSquared),`
327	`704`	`WideArithmetic.MultiplySigned576ToSigned832(`
327	`705`	`firstDot,`
327	`706`	`secondDot));`
	`707`
	`708`	`private static Signed832 GetProjectedDiskRadialCoefficient(`
	`709`	`Signed576 xSquared,`
	`710`	`Signed576 zSquared,`
	`711`	`Signed320 axisYSquared) =>`
545	`712`	`WideArithmetic.MultiplySigned576ToSigned832(`
545	`713`	`WideArithmetic.AddSigned576(`
545	`714`	`xSquared,`
545	`715`	`zSquared),`
545	`716`	`axisYSquared);`
	`717`
	`718`	`private static void GetSquaredPolynomial(`
	`719`	`Signed320 constant,`
	`720`	`Signed320 linear,`
	`721`	`Signed320 quadratic,`
	`722`	`out Signed576 result0,`
	`723`	`out Signed576 result1,`
	`724`	`out Signed576 result2,`
	`725`	`out Signed576 result3,`
	`726`	`out Signed576 result4)`
	`727`	`{`
218	`728`	`result0 = WideArithmetic.MultiplySigned320(`
218	`729`	`constant,`
218	`730`	`constant);`
218	`731`	`result1 = WideArithmetic.AddSigned576(`
218	`732`	`WideArithmetic.MultiplySigned320(`
218	`733`	`constant,`
218	`734`	`linear),`
218	`735`	`WideArithmetic.MultiplySigned320(`
218	`736`	`constant,`
218	`737`	`linear));`
218	`738`	`result2 = WideArithmetic.AddSigned576(`
218	`739`	`WideArithmetic.MultiplySigned320(`
218	`740`	`linear,`
218	`741`	`linear),`
218	`742`	`WideArithmetic.AddSigned576(`
218	`743`	`WideArithmetic.MultiplySigned320(`
218	`744`	`constant,`
218	`745`	`quadratic),`
218	`746`	`WideArithmetic.MultiplySigned320(`
218	`747`	`constant,`
218	`748`	`quadratic)));`
218	`749`	`result3 = WideArithmetic.AddSigned576(`
218	`750`	`WideArithmetic.MultiplySigned320(`
218	`751`	`linear,`
218	`752`	`quadratic),`
218	`753`	`WideArithmetic.MultiplySigned320(`
218	`754`	`linear,`
218	`755`	`quadratic));`
218	`756`	`result4 = WideArithmetic.MultiplySigned320(`
218	`757`	`quadratic,`
218	`758`	`quadratic);`
218	`759`	`}`
	`760`
	`761`	`private static Signed320 MultiplyBySmall(`
	`762`	`Signed320 value,`
	`763`	`int multiplier)`
	`764`	`{`
654	`765`	`if (multiplier == 0)`
218	`766`	`return default;`
436	`767`	`Signed320 result = multiplier < 0`
436	`768`	`? WideArithmetic.SubtractSigned320(default, value)`
436	`769`	`: value;`
436	`770`	`return multiplier is 2 or -2`
436	`771`	`? WideArithmetic.AddSigned320(result, result)`
436	`772`	`: result;`
	`773`	`}`
	`774`
	`775`	`private static Signed832 DoubleSigned832(Signed832 value) =>`
436	`776`	`WideArithmetic.AddSigned832(value, value);`
	`777`
	`778`	`private static int EvaluateProjectedDiskConic(`
	`779`	`Signed320 relativeX,`
	`780`	`Signed320 relativeZ,`
	`781`	`Signed192 coordinateDenominator,`
	`782`	`Signed192 axisX,`
	`783`	`Signed192 axisY,`
	`784`	`Signed192 axisZ,`
	`785`	`Fixed64 diskRadius)`
	`786`	`{`
132	`787`	`Signed576 distanceSquared = WideArithmetic.AddSigned576(`
132	`788`	`WideArithmetic.MultiplySigned320(`
132	`789`	`relativeX,`
132	`790`	`relativeX),`
132	`791`	`WideArithmetic.MultiplySigned320(`
132	`792`	`relativeZ,`
132	`793`	`relativeZ));`
132	`794`	`Signed576 dot = WideArithmetic.AddSigned576(`
132	`795`	`WideArithmetic.MultiplySigned320(`
132	`796`	`relativeX,`
132	`797`	`Signed320.ExtendValue(axisX)),`
132	`798`	`WideArithmetic.MultiplySigned320(`
132	`799`	`relativeZ,`
132	`800`	`Signed320.ExtendValue(axisZ)));`
132	`801`	`Signed320 axisY2 = WideArithmetic.MultiplySigned192(`
132	`802`	`axisY,`
132	`803`	`axisY);`
132	`804`	`Signed832 left = WideArithmetic.AddSigned832(`
132	`805`	`WideArithmetic.MultiplySigned576ToSigned832(`
132	`806`	`distanceSquared,`
132	`807`	`axisY2),`
132	`808`	`WideArithmetic.MultiplySigned576ToSigned832(`
132	`809`	`dot,`
132	`810`	`dot));`
132	`811`	`Signed320 radiusSquared = WideArithmetic.MultiplySigned192(`
132	`812`	`Signed192.Raw(diskRadius),`
132	`813`	`Signed192.Raw(diskRadius));`
132	`814`	`Signed576 radiusAndAxis = WideArithmetic.MultiplySigned320(`
132	`815`	`radiusSquared,`
132	`816`	`axisY2);`
132	`817`	`Signed320 denominatorSquared =`
132	`818`	`WideArithmetic.MultiplySigned192(`
132	`819`	`coordinateDenominator,`
132	`820`	`coordinateDenominator);`
132	`821`	`Signed832 right =`
132	`822`	`WideArithmetic.MultiplySigned576ToSigned832(`
132	`823`	`radiusAndAxis,`
132	`824`	`denominatorSquared);`
132	`825`	`return WideArithmetic.SubtractSigned832(left, right).Sign;`
	`826`	`}`
	`827`	`}`

/home/runner/work/FixedMathSharp/FixedMathSharp/src/FixedMathSharp/Geometry/Wide/Common/WidePlanarProjection.Polygon.cs

#	Line	Line coverage
	`1`	`//=======================================================================`
	`2`	`// WidePlanarProjection.Polygon.cs`
	`3`	`//=======================================================================`
	`4`	`// MIT License, Copyright (c) 2024-present David Oravsky (mrdav30)`
	`5`	`// See LICENSE file in the project root for full license information.`
	`6`	`//=======================================================================`
	`7`
	`8`	`using System;`
	`9`
	`10`	`namespace FixedMathSharp.Geometry;`
	`11`
	`12`	`/// <content>`
	`13`	`/// Exact rational polygon projection and closest-feature reduction.`
	`14`	`/// </content>`
	`15`	`internal static partial class WidePlanarProjection`
	`16`	`{`
	`17`	`private const int DistanceComparisonWordCount = 36;`
	`18`
	`19`	`internal static bool TryGetOrientedBoxRelation(`
	`20`	`Vector2d circleCenter,`
	`21`	`Fixed64 circleRadius,`
	`22`	`FixedOrientedBox box,`
	`23`	`out PlanarProjectionRelation relation)`
	`24`	`{`
5	`25`	`WideRationalBasis3d basis = new(box.Orientation);`
5	`26`	`Span<RationalPoint> corners = stackalloc RationalPoint[8];`
5	`27`	`int index = 0;`
30	`28`	`for (int x = -1; x <= 1; x += 2)`
	`29`	`{`
60	`30`	`for (int y = -1; y <= 1; y += 2)`
	`31`	`{`
120	`32`	`for (int z = -1; z <= 1; z += 2)`
	`33`	`{`
40	`34`	`corners[index++] = GetWorldPoint(`
40	`35`	`box.Center,`
40	`36`	`basis,`
40	`37`	`new Vector3d(`
40	`38`	`x * box.HalfExtents.X,`
40	`39`	`y * box.HalfExtents.Y,`
40	`40`	`z * box.HalfExtents.Z));`
	`41`	`}`
	`42`	`}`
	`43`	`}`
	`44`
5	`45`	`Span<RationalPoint> hull = stackalloc RationalPoint[8];`
5	`46`	`int count = BuildConvexHull(corners, hull);`
5	`47`	`return TryGetConvexRelation(`
5	`48`	`circleCenter,`
5	`49`	`circleRadius,`
5	`50`	`basis.Denominator,`
5	`51`	`hull[..count],`
5	`52`	`out relation);`
	`53`	`}`
	`54`
	`55`	`internal static bool TryGetTriangleRelation(`
	`56`	`Vector2d circleCenter,`
	`57`	`Fixed64 circleRadius,`
	`58`	`FixedTriangle triangle,`
	`59`	`Vector3d triangleOrigin,`
	`60`	`FixedQuaternion triangleRotation,`
	`61`	`out PlanarProjectionRelation relation)`
	`62`	`{`
5	`63`	`WideRationalBasis3d basis = new(triangleRotation);`
5	`64`	`Span<RationalPoint> vertices = stackalloc RationalPoint[3];`
5	`65`	`vertices[0] = GetWorldPoint(`
5	`66`	`triangleOrigin,`
5	`67`	`basis,`
5	`68`	`triangle.A);`
5	`69`	`vertices[1] = GetWorldPoint(`
5	`70`	`triangleOrigin,`
5	`71`	`basis,`
5	`72`	`triangle.B);`
5	`73`	`vertices[2] = GetWorldPoint(`
5	`74`	`triangleOrigin,`
5	`75`	`basis,`
5	`76`	`triangle.C);`
	`77`
5	`78`	`if (ContainsPoint(`
5	`79`	`circleCenter,`
5	`80`	`basis.Denominator,`
5	`81`	`vertices))`
	`82`	`{`
1	`83`	`relation = PlanarProjectionRelation.Contained;`
1	`84`	`return true;`
	`85`	`}`
	`86`
4	`87`	`RationalDistance best = GetSegmentDistance(`
4	`88`	`circleCenter,`
4	`89`	`basis.Denominator,`
4	`90`	`vertices[0],`
4	`91`	`vertices[1]);`
4	`92`	`KeepCloser(`
4	`93`	`GetSegmentDistance(`
4	`94`	`circleCenter,`
4	`95`	`basis.Denominator,`
4	`96`	`vertices[1],`
4	`97`	`vertices[2]),`
4	`98`	`ref best);`
4	`99`	`KeepCloser(`
4	`100`	`GetSegmentDistance(`
4	`101`	`circleCenter,`
4	`102`	`basis.Denominator,`
4	`103`	`vertices[2],`
4	`104`	`vertices[0]),`
4	`105`	`ref best);`
4	`106`	`return TryCreateRelation(`
4	`107`	`best,`
4	`108`	`circleRadius,`
4	`109`	`out relation);`
	`110`	`}`
	`111`
	`112`	`private static bool TryGetConvexRelation(`
	`113`	`Vector2d circleCenter,`
	`114`	`Fixed64 circleRadius,`
	`115`	`Signed192 denominator,`
	`116`	`ReadOnlySpan<RationalPoint> vertices,`
	`117`	`out PlanarProjectionRelation relation)`
	`118`	`{`
6	`119`	`if (ContainsPoint(`
6	`120`	`circleCenter,`
6	`121`	`denominator,`
6	`122`	`vertices))`
	`123`	`{`
2	`124`	`relation = PlanarProjectionRelation.Contained;`
2	`125`	`return true;`
	`126`	`}`
	`127`
4	`128`	`RationalDistance best = GetSegmentDistance(`
4	`129`	`circleCenter,`
4	`130`	`denominator,`
4	`131`	`vertices[0],`
4	`132`	`vertices[1]);`
30	`133`	`for (int index = 1; index < vertices.Length; index++)`
	`134`	`{`
11	`135`	`KeepCloser(`
11	`136`	`GetSegmentDistance(`
11	`137`	`circleCenter,`
11	`138`	`denominator,`
11	`139`	`vertices[index],`
11	`140`	`vertices[`
11	`141`	`index + 1 == vertices.Length`
11	`142`	`? 0`
11	`143`	`: index + 1]),`
11	`144`	`ref best);`
	`145`	`}`
	`146`
4	`147`	`return TryCreateRelation(`
4	`148`	`best,`
4	`149`	`circleRadius,`
4	`150`	`out relation);`
	`151`	`}`
	`152`
	`153`	`private static bool TryCreateRelation(`
	`154`	`RationalDistance distance,`
	`155`	`Fixed64 circleRadius,`
	`156`	`out PlanarProjectionRelation relation)`
	`157`	`{`
9	`158`	`if (distance.SquaredDistance.IsZero)`
	`159`	`{`
1	`160`	`relation = PlanarProjectionRelation.Contained;`
1	`161`	`return true;`
	`162`	`}`
	`163`
8	`164`	`if (!TryGetDistance(`
8	`165`	`distance,`
8	`166`	`circleRadius,`
8	`167`	`out Fixed64 result))`
	`168`	`{`
2	`169`	`relation = default;`
2	`170`	`return false;`
	`171`	`}`
	`172`
6	`173`	`relation = new PlanarProjectionRelation(`
6	`174`	`result,`
6	`175`	`GetOffset(distance),`
6	`176`	`WideNormalization.GetNormalized(`
6	`177`	`distance.X,`
6	`178`	`distance.Z));`
6	`179`	`return true;`
	`180`	`}`
	`181`
	`182`	`private static bool ContainsPoint(`
	`183`	`Vector2d point,`
	`184`	`Signed192 denominator,`
	`185`	`ReadOnlySpan<RationalPoint> vertices)`
	`186`	`{`
11	`187`	`int winding = 0;`
11	`188`	`Signed320 pointX = WideArithmetic.MultiplySigned192(`
11	`189`	`Signed192.Raw(point.X),`
11	`190`	`denominator);`
11	`191`	`Signed320 pointZ = WideArithmetic.MultiplySigned192(`
11	`192`	`Signed192.Raw(point.Y),`
11	`193`	`denominator);`
78	`194`	`for (int index = 0; index < vertices.Length; index++)`
	`195`	`{`
34	`196`	`RationalPoint first = vertices[index];`
34	`197`	`RationalPoint second = vertices[`
34	`198`	`index + 1 == vertices.Length ? 0 : index + 1];`
34	`199`	`Signed576 cross = Cross(`
34	`200`	`WideArithmetic.SubtractSigned320(`
34	`201`	`second.X,`
34	`202`	`first.X),`
34	`203`	`WideArithmetic.SubtractSigned320(`
34	`204`	`second.Z,`
34	`205`	`first.Z),`
34	`206`	`WideArithmetic.SubtractSigned320(`
34	`207`	`pointX,`
34	`208`	`first.X),`
34	`209`	`WideArithmetic.SubtractSigned320(`
34	`210`	`pointZ,`
34	`211`	`first.Z));`
34	`212`	`int sign = cross.Sign;`
34	`213`	`if (sign == 0)`
	`214`	`continue;`
26	`215`	`if (winding == 0)`
9	`216`	`winding = sign;`
17	`217`	`else if (winding != sign)`
6	`218`	`return false;`
	`219`	`}`
	`220`
5	`221`	`return winding != 0;`
	`222`	`}`
	`223`
	`224`	`private static int BuildConvexHull(`
	`225`	`Span<RationalPoint> points,`
	`226`	`Span<RationalPoint> hull)`
	`227`	`{`
5	`228`	`SortAndDeduplicate(points, out int uniqueCount);`
5	`229`	`Span<RationalPoint> work =`
5	`230`	`stackalloc RationalPoint[16];`
5	`231`	`int count = 0;`
50	`232`	`for (int index = 0; index < uniqueCount; index++)`
	`233`	`{`
25	`234`	`while (count >= 2`
25	`235`	`&& GetTurn(`
25	`236`	`work[count - 2],`
25	`237`	`work[count - 1],`
25	`238`	`points[index]) <= 0)`
	`239`	`{`
5	`240`	`count--;`
	`241`	`}`
20	`242`	`work[count++] = points[index];`
	`243`	`}`
	`244`
5	`245`	`int lowerCount = count;`
40	`246`	`for (int index = uniqueCount - 2; index >= 0; index--)`
	`247`	`{`
20	`248`	`while (count > lowerCount`
20	`249`	`&& GetTurn(`
20	`250`	`work[count - 2],`
20	`251`	`work[count - 1],`
20	`252`	`points[index]) <= 0)`
	`253`	`{`
5	`254`	`count--;`
	`255`	`}`
15	`256`	`work[count++] = points[index];`
	`257`	`}`
	`258`
5	`259`	`count--;`
5	`260`	`work[..count].CopyTo(hull);`
5	`261`	`return count;`
	`262`	`}`
	`263`
	`264`	`private static void SortAndDeduplicate(`
	`265`	`Span<RationalPoint> points,`
	`266`	`out int count)`
	`267`	`{`
80	`268`	`for (int index = 1; index < points.Length; index++)`
	`269`	`{`
35	`270`	`RationalPoint value = points[index];`
35	`271`	`int destination = index;`
65	`272`	`while (destination > 0`
65	`273`	`&& ComparePoint(`
65	`274`	`value,`
65	`275`	`points[destination - 1]) < 0)`
	`276`	`{`
30	`277`	`points[destination] =`
30	`278`	`points[destination - 1];`
30	`279`	`destination--;`
	`280`	`}`
35	`281`	`points[destination] = value;`
	`282`	`}`
	`283`
5	`284`	`count = 1;`
80	`285`	`for (int index = 1; index < points.Length; index++)`
	`286`	`{`
35	`287`	`if (ComparePoint(points[index], points[count - 1]) == 0)`
	`288`	`continue;`
15	`289`	`points[count++] = points[index];`
	`290`	`}`
5	`291`	`}`
	`292`
	`293`	`private static int ComparePoint(`
	`294`	`RationalPoint first,`
	`295`	`RationalPoint second)`
	`296`	`{`
97	`297`	`int comparison = WideArithmetic.SubtractSigned320(`
97	`298`	`first.X,`
97	`299`	`second.X).Sign;`
97	`300`	`return comparison != 0`
97	`301`	`? comparison`
97	`302`	`: WideArithmetic.SubtractSigned320(`
97	`303`	`first.Z,`
97	`304`	`second.Z).Sign;`
	`305`	`}`
	`306`
	`307`	`private static int GetTurn(`
	`308`	`RationalPoint first,`
	`309`	`RationalPoint second,`
	`310`	`RationalPoint third) =>`
20	`311`	`Cross(`
20	`312`	`WideArithmetic.SubtractSigned320(`
20	`313`	`second.X,`
20	`314`	`first.X),`
20	`315`	`WideArithmetic.SubtractSigned320(`
20	`316`	`second.Z,`
20	`317`	`first.Z),`
20	`318`	`WideArithmetic.SubtractSigned320(`
20	`319`	`third.X,`
20	`320`	`second.X),`
20	`321`	`WideArithmetic.SubtractSigned320(`
20	`322`	`third.Z,`
20	`323`	`second.Z)).Sign;`
	`324`
	`325`	`private static Signed576 Cross(`
	`326`	`Signed320 firstX,`
	`327`	`Signed320 firstZ,`
	`328`	`Signed320 secondX,`
	`329`	`Signed320 secondZ) =>`
54	`330`	`WideArithmetic.SubtractSigned576(`
54	`331`	`WideArithmetic.MultiplySigned320(`
54	`332`	`firstX,`
54	`333`	`secondZ),`
54	`334`	`WideArithmetic.MultiplySigned320(`
54	`335`	`firstZ,`
54	`336`	`secondX));`
	`337`
	`338`	`private static void KeepCloser(`
	`339`	`RationalDistance candidate,`
	`340`	`ref RationalDistance best)`
	`341`	`{`
19	`342`	`if (CompareDistances(candidate, best) < 0)`
5	`343`	`best = candidate;`
19	`344`	`}`
	`345`
	`346`	`private static int CompareDistances(`
	`347`	`RationalDistance first,`
	`348`	`RationalDistance second)`
	`349`	`{`
19	`350`	`Signed832 firstDenominatorSquared =`
19	`351`	`WideArithmetic.MultiplySigned576ToSigned832(`
19	`352`	`first.Denominator,`
19	`353`	`first.Denominator);`
19	`354`	`Signed832 secondDenominatorSquared =`
19	`355`	`WideArithmetic.MultiplySigned576ToSigned832(`
19	`356`	`second.Denominator,`
19	`357`	`second.Denominator);`
19	`358`	`Span<ulong> firstSquaredMagnitude = stackalloc ulong[13];`
19	`359`	`Span<ulong> secondSquaredMagnitude = stackalloc ulong[13];`
19	`360`	`Span<ulong> firstDenominatorMagnitude = stackalloc ulong[13];`
19	`361`	`Span<ulong> secondDenominatorMagnitude = stackalloc ulong[13];`
19	`362`	`WideArithmetic.GetMagnitude(`
19	`363`	`first.SquaredDistance,`
19	`364`	`firstSquaredMagnitude);`
19	`365`	`WideArithmetic.GetMagnitude(`
19	`366`	`second.SquaredDistance,`
19	`367`	`secondSquaredMagnitude);`
19	`368`	`WideArithmetic.GetMagnitude(`
19	`369`	`firstDenominatorSquared,`
19	`370`	`firstDenominatorMagnitude);`
19	`371`	`WideArithmetic.GetMagnitude(`
19	`372`	`secondDenominatorSquared,`
19	`373`	`secondDenominatorMagnitude);`
19	`374`	`Span<ulong> left =`
19	`375`	`stackalloc ulong[DistanceComparisonWordCount];`
19	`376`	`Span<ulong> right =`
19	`377`	`stackalloc ulong[DistanceComparisonWordCount];`
19	`378`	`WideArithmetic.MultiplyMagnitudes(`
19	`379`	`firstSquaredMagnitude,`
19	`380`	`secondDenominatorMagnitude,`
19	`381`	`left);`
19	`382`	`WideArithmetic.MultiplyMagnitudes(`
19	`383`	`secondSquaredMagnitude,`
19	`384`	`firstDenominatorMagnitude,`
19	`385`	`right);`
19	`386`	`return WideArithmetic.CompareMagnitudeEqualLength(`
19	`387`	`left,`
19	`388`	`right);`
	`389`	`}`
	`390`	`}`

Methods/Properties