< Summary

Information

Class:	FixedMathSharp.Geometry.WideTriangleConeIntersection
Assembly:	FixedMathSharp
File(s):	File 1: /home/runner/work/FixedMathSharp/FixedMathSharp/src/FixedMathSharp/Geometry/Wide/FiniteAxis/WideTriangleConeIntersection.cs File 2: /home/runner/work/FixedMathSharp/FixedMathSharp/src/FixedMathSharp/Geometry/Wide/FiniteAxis/WideTriangleConeIntersection.ScaledFrame.cs

Line coverage

100%

Covered lines:	365
Uncovered lines:	0
Coverable lines:	365
Total lines:	601
Line coverage:	100%

Branch coverage

100%

Covered branches:	196
Total branches:	196
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: .cctor()	100%	1	1	100%
File 1: TryGetMinimumAxialPoint(...)	100%	16	16	100%
File 1: .ctor(...)	100%	6	6	100%
File 1: GetAxialParameter(...)	100%	2	2	100%
File 1: TryGetEdgePoint(...)	100%	24	24	100%
File 1: Transform(...)	100%	1	1	100%
File 1: GetEdgeCoefficient(...)	100%	1	1	100%
File 1: TryGetFacePoint(...)	100%	24	24	100%
File 1: TryGetAxisPlaneRatio(...)	100%	8	8	100%
File 1: ContainsAxisPoint(...)	100%	4	4	100%
File 1: ContainsStationaryPoint(...)	100%	4	4	100%
File 1: GetEdgeProducts(...)	100%	1	1	100%
File 1: WitnessCoordinate(...)	100%	1	1	100%
File 1: AxisCoordinate(...)	100%	1	1	100%
File 1: SumProductSign(...)	100%	6	6	100%
File 1: Ratio(...)	100%	1	1	100%
File 1: Product(...)	100%	1	1	100%
File 1: Product(...)	100%	1	1	100%
File 1: Product(...)	100%	1	1	100%
File 1: Product(...)	100%	1	1	100%
File 1: Extend(...)	100%	1	1	100%
File 1: Narrow(...)	100%	1	1	100%
File 1: Axis(...)	100%	1	1	100%
File 1: Raw(...)	100%	1	1	100%
File 1: Difference(...)	100%	1	1	100%
File 1: Add(...)	100%	1	1	100%
File 1: Subtract(...)	100%	1	1	100%
File 1: Multiply(...)	100%	1	1	100%
File 1: Dot(...)	100%	1	1	100%
File 2: TryGetMinimumAxialPoint(...)	100%	18	18	100%
File 2: GetScaledConeAxial(...)	100%	1	1	100%
File 2: GetScaledConeRelativePoint(...)	100%	1	1	100%
File 2: TryGetScaledConeEdgePoint(...)	100%	8	8	100%
File 2: BuildScaledConeEdgeCoefficient(...)	100%	1	1	100%
File 2: TryGetScaledConeFacePoint(...)	100%	32	32	100%
File 2: TryGetScaledConeAxisPoint(...)	100%	10	10	100%
File 2: TryGetScaledConeStationaryPoint(...)	100%	16	16	100%
File 2: ContainsScaledConeFacePoint(...)	100%	18	18	100%
File 2: PackScaledCone832(...)	100%	1	1	100%

File(s)

/home/runner/work/FixedMathSharp/FixedMathSharp/src/FixedMathSharp/Geometry/Wide/FiniteAxis/WideTriangleConeIntersection.cs

#	Line	Line coverage
	`1`	`//=======================================================================`
	`2`	`// WideTriangleConeIntersection.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>Exact edge/face minimum-axial reduction in the triangle's authored frame.</summary>`
	`13`	`internal static partial class WideTriangleConeIntersection`
	`14`	`{`
1	`15`	`private static readonly Signed192 Scale = Signed192.Raw(Fixed64.One);`
1	`16`	`private static readonly Signed192 MaximumParameter = Signed192.Raw(Fixed64.MaxValue);`
	`17`
	`18`	`internal static bool TryGetMinimumAxialPoint(FixedTriangle triangle, Vector3d origin,`
	`19`	`FixedQuaternion rotation, Vector3d apex, Vector3d axis, Fixed64 height, Fixed64 radius,`
	`20`	`out Vector3d point)`
	`21`	`{`
139	`22`	`var frame = new QueryFrame(origin, rotation, apex, axis);`
139	`23`	`bool found = false;`
139	`24`	`point = default;`
139	`25`	`Fixed64 bestAxial = Fixed64.MaxValue;`
1112	`26`	`for (int index = 0; index < 3; index++)`
	`27`	`{`
417	`28`	`FixedSegment edge = triangle.GetEdge(index);`
417	`29`	`if (!frame.TryGetEdgePoint(edge, height, radius, out Vector3d candidate))`
	`30`	`continue;`
	`31`	`// Equal candidates retain authored AB, BC, CA order after the same`
	`32`	`// local-point rounding and cone-parameter projection in either frame.`
99	`33`	`Fixed64 axial = frame.GetAxialParameter(candidate, height);`
99	`34`	`if (found && axial >= bestAxial)`
	`35`	`continue;`
67	`36`	`found = true;`
67	`37`	`point = candidate;`
67	`38`	`bestAxial = axial;`
	`39`	`}`
139	`40`	`triangle.GetExactNormal(out Signed192 nx, out Signed192 ny, out Signed192 nz, out Signed320 nSquared);`
139	`41`	`if (!WideGeometry.IsQ128MagnitudeAtMostEpsilon(nSquared)`
139	`42`	`&& TryGetFacePoint(triangle, frame, Axis(nx, ny, nz), nSquared, height, radius, found,`
139	`43`	`out Vector3d facePoint, out Fixed64 faceAxial)`
139	`44`	`&& (!found \|\| faceAxial < bestAxial))`
	`45`	`{`
60	`46`	`found = true;`
60	`47`	`point = facePoint;`
	`48`	`}`
139	`49`	`return found;`
	`50`	`}`
	`51`
	`52`	`private readonly struct QueryFrame`
	`53`	`{`
	`54`	`internal readonly WideAxis3 Apex, Axis;`
	`55`	`internal readonly Signed192 Denominator, AxisSquared;`
	`56`	`internal readonly bool Compact;`
	`57`	`internal readonly Vector3d LocalApex;`
	`58`	`private readonly WideRationalBasis3d basis;`
	`59`	`private readonly Vector3d origin, worldApex, worldAxis;`
	`60`	`private readonly bool identity;`
	`61`
	`62`	`internal QueryFrame(Vector3d origin, FixedQuaternion rotation, Vector3d apex, Vector3d axis)`
	`63`	`{`
417	`64`	`this.origin = origin; worldApex = apex; worldAxis = axis;`
139	`65`	`identity = rotation == FixedQuaternion.Identity;`
139	`66`	`basis = identity ? default : new WideRationalBasis3d(rotation);`
139	`67`	`Vector3d localApex = default;`
139	`68`	`Compact = identity && Vector3d.TrySubtract(apex, origin, out localApex);`
139	`69`	`LocalApex = localApex;`
139	`70`	`AxisSquared = Signed192.NarrowProven(Dot(Raw(axis), Raw(axis)));`
139	`71`	`if (identity)`
	`72`	`{`
115	`73`	`Denominator = Signed192.Signed(1);`
115	`74`	`Apex = Difference(apex, origin);`
115	`75`	`Axis = Raw(axis);`
115	`76`	`return;`
	`77`	`}`
24	`78`	`WideOrientedBox.GetRelativeLocalPointNumerators(apex, origin, basis,`
24	`79`	`out Signed192 ax, out Signed192 ay, out Signed192 az);`
24	`80`	`WideOrientedBox.GetRelativeLocalPointNumerators(axis, Vector3d.Zero, basis,`
24	`81`	`out Signed192 dx, out Signed192 dy, out Signed192 dz);`
24	`82`	`Span<Signed320> values = stackalloc Signed320[7]`
24	`83`	`{`
24	`84`	`Signed320.ExtendValue(basis.Denominator), Signed320.ExtendValue(ax),`
24	`85`	`Signed320.ExtendValue(ay), Signed320.ExtendValue(az), Signed320.ExtendValue(dx),`
24	`86`	`Signed320.ExtendValue(dy), Signed320.ExtendValue(dz)`
24	`87`	`};`
24	`88`	`WideArithmetic.ReduceCommonScale(values);`
24	`89`	`Denominator = Signed192.NarrowProven(values[0]);`
24	`90`	`Apex = new WideAxis3(values[1], values[2], values[3]);`
24	`91`	`Axis = new WideAxis3(values[4], values[5], values[6]);`
24	`92`	`}`
	`93`
	`94`	`internal Fixed64 GetAxialParameter(Vector3d point, Fixed64 height)`
	`95`	`{`
99	`96`	`if (Compact)`
86	`97`	`return FixedMath.Min(Vector3d.ProjectNonNegativeDifferenceParameter(point, LocalApex, worldAxis), height`
	`98`
	`99`	`// Compare the same nearest-even cone parameter as face candidates,`
	`100`	`// not a floored dot: an admitted unit axis need not have exact length 1.`
13	`101`	`Signed320 numerator = Dot(Subtract(Multiply(Raw(point), Denominator), Apex), Axis);`
13	`102`	`Signed320 denominator = Signed320.NarrowValue(WideArithmetic.MultiplySigned576(`
13	`103`	`Signed576.ExtendValue(WideArithmetic.MultiplySigned192(AxisSquared, Denominator)), Denominator));`
13	`104`	`return FixedMath.Clamp(Fixed64.GetSignedRatio(numerator, denominator), Fixed64.Zero, height);`
	`105`	`}`
	`106`
	`107`	`internal bool TryGetEdgePoint(FixedSegment edge, Fixed64 height, Fixed64 radius, out Vector3d point)`
	`108`	`{`
	`109`	`// Only an exact translation qualifies for the compact segment path.`
	`110`	`// Rounded rotation or saturating origin subtraction cannot do so.`
417	`111`	`if (Compact)`
342	`112`	`return edge.TryGetFiniteConeIntersectionMinimumAxialPoint(LocalApex, worldAxis, height, radius, out poin`
	`113`
	`114`	`WideAxis3 start, delta;`
	`115`	`Signed192 denominator;`
75	`116`	`if (identity)`
	`117`	`{`
3	`118`	`start = Subtract(Raw(edge.Start), Apex);`
3	`119`	`delta = Difference(edge.End, edge.Start);`
3	`120`	`denominator = Signed192.Signed(1);`
	`121`	`}`
	`122`	`else`
	`123`	`{`
72	`124`	`WideAxis3 offset = Difference(origin, worldApex);`
72	`125`	`start = Add(Transform(edge.Start), Multiply(offset, basis.Denominator));`
72	`126`	`WideAxis3 localDelta = Difference(edge.End, edge.Start);`
72	`127`	`delta = WideRigidProjection.TransformLocalAxis(basis, Narrow(localDelta.X), Narrow(localDelta.Y), Narrow`
72	`128`	`denominator = basis.Denominator;`
	`129`	`}`
75	`130`	`Signed192 startProjection = Signed192.NarrowProven(Dot(start, Raw(worldAxis)));`
75	`131`	`Signed192 velocityProjection = Signed192.NarrowProven(Dot(delta, Raw(worldAxis)));`
75	`132`	`Signed320 startAxial = WideArithmetic.MultiplySigned192(startProjection, Scale);`
75	`133`	`Signed320 velocity = WideArithmetic.MultiplySigned192(velocityProjection, Scale);`
75	`134`	`Signed320 maximum = Signed320.NarrowValue(WideArithmetic.MultiplySigned576(`
75	`135`	`Signed576.ExtendValue(WideArithmetic.MultiplySigned192(AxisSquared, Signed192.Raw(height))), denominator`
300	`136`	`Signed320 lowerN = default, lowerD = Signed320.ExtendValue(Signed192.Signed(1)), upperN = Signed320.ExtendVa`
75	`137`	`if (velocity.IsZero)`
	`138`	`{`
22	`139`	`if (startAxial.Sign < 0 \|\| WideArithmetic.SubtractSigned320(startAxial, maximum).Sign > 0)`
32	`140`	`{ point = default; return false; }`
	`141`	`}`
	`142`	`else`
	`143`	`{`
53	`144`	`Signed320 first = WideArithmetic.Negate(startAxial);`
53	`145`	`Signed320 second = WideArithmetic.SubtractSigned320(maximum, startAxial);`
53	`146`	`Signed320 divisor = velocity;`
53	`147`	`if (velocity.Sign < 0)`
	`148`	`{`
27	`149`	`(first, second) = (WideArithmetic.Negate(second), WideArithmetic.Negate(first));`
27	`150`	`divisor = WideArithmetic.Negate(divisor);`
	`151`	`}`
53	`152`	`if (second.Sign < 0 \|\| WideArithmetic.SubtractSigned320(first, divisor).Sign > 0)`
28	`153`	`{ point = default; return false; }`
89	`154`	`if (first.Sign > 0) { lowerN = first; lowerD = divisor; }`
89	`155`	`if (WideArithmetic.SubtractSigned320(second, divisor).Sign < 0) { upperN = second; upperD = divisor; }`
	`156`	`}`
45	`157`	`Signed576 a = GetEdgeCoefficient(Dot(delta, delta), velocityProjection, velocityProjection, AxisSquared, hei`
45	`158`	`Signed576 b = GetEdgeCoefficient(Dot(start, delta), startProjection, velocityProjection, AxisSquared, height`
45	`159`	`Signed576 c = GetEdgeCoefficient(Dot(start, start), startProjection, startProjection, AxisSquared, height, r`
45	`160`	`if (!WideFiniteConeIntersection.TrySolveBoundedUnitPolynomial(`
45	`161`	`Signed832.ExtendValue(a), Signed832.ExtendValue(b), Signed832.ExtendValue(c),`
45	`162`	`lowerN, lowerD, upperN, upperD, Fixed64.MaxValue, out Fixed64 entry, out Fixed64 exit))`
64	`163`	`{ point = default; return false; }`
13	`164`	`point = edge.GetPointAtDistance(velocity.Sign < 0 ? exit : entry, Fixed64.MaxValue);`
13	`165`	`return true;`
	`166`	`}`
	`167`
72	`168`	`private WideAxis3 Transform(Vector3d point) => WideRigidProjection.TransformLocalAxis(basis,`
72	`169`	`Signed192.Raw(point.X), Signed192.Raw(point.Y), Signed192.Raw(point.Z));`
	`170`	`}`
	`171`
	`172`	`private static Signed576 GetEdgeCoefficient(Signed320 squared, Signed192 first, Signed192 second,`
	`173`	`Signed192 q, Fixed64 height, Fixed64 radius)`
	`174`	`{`
	`175`	`// For P(t)=start+t*delta and q=axis.axis, radial distance is`
	`176`	`// (q*P.P-(P.axis)^2)/q. Keep t's axial clipping separate and expand`
	`177`	`// H²q(qP.P-(P.axis)^2)-R²Q²*(P.axis)^2 <= 0 exactly.`
	`178`	`// P and E have <133 bits, their axial dots <168. After retaining the`
	`179`	`// common rigid denominator, cone coefficients still fit below 530 bits.`
135	`180`	`Signed576 axial = WideArithmetic.MultiplySigned320(Signed320.ExtendValue(first), Signed320.ExtendValue(second));`
135	`181`	`Signed576 radial = WideArithmetic.SubtractSigned576(`
135	`182`	`WideArithmetic.MultiplySigned576(Signed576.ExtendValue(squared), q), axial);`
135	`183`	`return WideArithmetic.SubtractSigned576(`
135	`184`	`WideArithmetic.MultiplySigned576(radial, q, Signed192.Raw(height), Signed192.Raw(height)),`
135	`185`	`WideArithmetic.MultiplySigned576(axial, Scale, Scale, Signed192.Raw(radius), Signed192.Raw(radius)));`
	`186`	`}`
	`187`
	`188`	`private static bool TryGetFacePoint(FixedTriangle triangle, in QueryFrame frame, WideAxis3 normal,`
	`189`	`Signed320 normalSquared, Fixed64 height, Fixed64 radius, bool hasEdge,`
	`190`	`out Vector3d point, out Fixed64 axial)`
	`191`	`{`
272	`192`	`point = default; axial = default;`
	`193`	`// The plane is n.(X-apex)=c/D and its axial slope is b/D.`
	`194`	`// p=\|n\|²*\|axisNumerator\|²-b² is the squared radial plane normal.`
	`195`	`// At each axial parameter the stationary radial point is the first`
	`196`	`// place that plane's cone section can touch the triangle interior.`
136	`197`	`Signed320 b = Dot(normal, frame.Axis);`
136	`198`	`Signed320 c = Dot(normal, Subtract(Multiply(Raw(triangle.A), frame.Denominator), frame.Apex));`
136	`199`	`Signed320 qScaled = Signed320.NarrowValue(WideArithmetic.MultiplySigned576(`
136	`200`	`Signed576.ExtendValue(WideArithmetic.MultiplySigned192(frame.AxisSquared, frame.Denominator)), frame.Denomin`
136	`201`	`Signed576 p = WideArithmetic.SubtractSigned576(WideArithmetic.MultiplySigned320(normalSquared, qScaled),`
136	`202`	`WideArithmetic.MultiplySigned320(b, b));`
136	`203`	`bool crossesAxis = TryGetAxisPlaneRatio(b, c, height, out Signed320 axisN, out Signed320 axisD);`
136	`204`	`if (p.IsZero)`
	`205`	`{`
24	`206`	`if (hasEdge \|\| !crossesAxis \|\| !ContainsAxisPoint(triangle, normal, frame, axisN, axisD))`
17	`207`	`return false;`
7	`208`	`point = new Vector3d(AxisCoordinate(frame.Apex.X, frame.Axis.X, frame.Denominator, axisN, axisD),`
7	`209`	`AxisCoordinate(frame.Apex.Y, frame.Axis.Y, frame.Denominator, axisN, axisD),`
7	`210`	`AxisCoordinate(frame.Apex.Z, frame.Axis.Z, frame.Denominator, axisN, axisD));`
7	`211`	`axial = Ratio(WideArithmetic.MultiplySigned832(Extend(axisN), Scale), Extend(axisD));`
7	`212`	`return true;`
	`213`	`}`
	`214`	`// n<130, b<230, c<263, p<460 bits. Cancel the common D² from`
	`215`	`// the polynomial before multiplying: coefficients then need <660 bits.`
112	`216`	`Signed832 coefficient = WideArithmetic.SubtractSigned832(`
112	`217`	`Product(WideArithmetic.MultiplySigned320(b, b), frame.AxisSquared, Signed192.Raw(height), Signed192.Raw(heig`
112	`218`	`Product(p, Signed192.Raw(radius), Signed192.Raw(radius), Scale, Scale));`
112	`219`	`Signed832 projection = WideArithmetic.SubtractSigned832(default,`
112	`220`	`Product(WideArithmetic.MultiplySigned320(b, c), frame.AxisSquared, Scale, Signed192.Raw(height)));`
112	`221`	`Signed832 constant = Product(WideArithmetic.MultiplySigned320(c, c), frame.AxisSquared, Scale, Scale);`
112	`222`	`if (!WideFiniteConeIntersection.TrySolveBoundedUnitPolynomial(coefficient, projection, constant,`
112	`223`	`default, Signed320.ExtendValue(Signed192.Signed(1)), Signed320.ExtendValue(Signed192.Signed(1)), Signed3`
25	`224`	`return false;`
	`225`	`bool contained;`
87	`226`	`if (!hasEdge)`
36	`227`	`contained = crossesAxis ? ContainsAxisPoint(triangle, normal, frame, axisN, axisD)`
36	`228`	`: ContainsStationaryPoint(triangle, normal, normalSquared, frame, b, c, p, height, Fixed64.MaxValue);`
	`229`	`else`
	`230`	`{`
51	`231`	`int sign = WideFiniteConeIntersection.GetPolynomialSignAtRationalParameter(coefficient, projection, constant`
51	`232`	`Signed320.ExtendValue(Signed192.Raw(entry)), Signed320.ExtendValue(MaximumParameter));`
51	`233`	`Fixed64 lower = sign < 0 ? Fixed64.FromRaw(entry.m_rawValue - 1) : entry;`
51	`234`	`Fixed64 upper = sign > 0 ? Fixed64.FromRaw(entry.m_rawValue + 1) : entry;`
51	`235`	`contained = ContainsStationaryPoint(triangle, normal, normalSquared, frame, b, c, p, height, lower)`
51	`236`	`&& (lower == upper \|\| ContainsStationaryPoint(triangle, normal, normalSquared, frame, b, c, p, height, u`
	`237`	`}`
117	`238`	`if (!contained) return false;`
57	`239`	`point = new Vector3d(WitnessCoordinate(frame.Apex.X, frame.Axis.X, normal.X, frame.Denominator, qScaled, b, c, p`
57	`240`	`WitnessCoordinate(frame.Apex.Y, frame.Axis.Y, normal.Y, frame.Denominator, qScaled, b, c, p, height, entry),`
57	`241`	`WitnessCoordinate(frame.Apex.Z, frame.Axis.Z, normal.Z, frame.Denominator, qScaled, b, c, p, height, entry))`
57	`242`	`axial = Fixed64.GetSignedRawRatio(WideArithmetic.MultiplySigned192(Signed192.Raw(height), Signed192.Raw(entry)),`
57	`243`	`return true;`
	`244`	`}`
	`245`
	`246`	`private static bool TryGetAxisPlaneRatio(Signed320 b, Signed320 c, Fixed64 height, out Signed320 numerator, out Sign`
	`247`	`{`
136	`248`	`denominator = b.Sign < 0 ? WideArithmetic.Negate(b) : b;`
136	`249`	`numerator = b.Sign < 0 ? WideArithmetic.Negate(c) : c;`
136	`250`	`return !b.IsZero && numerator.Sign >= 0 && WideArithmetic.SubtractSigned576(`
136	`251`	`WideArithmetic.MultiplySigned576(Signed576.ExtendValue(numerator), Scale),`
136	`252`	`WideArithmetic.MultiplySigned576(Signed576.ExtendValue(denominator), Signed192.Raw(height))).Sign <= 0;`
	`253`	`}`
	`254`
	`255`	`private static bool ContainsAxisPoint(FixedTriangle triangle, WideAxis3 normal, in QueryFrame frame, Signed320 numer`
	`256`	`{`
156	`257`	`for (int index = 0; index < 3; index++)`
	`258`	`{`
63	`259`	`GetEdgeProducts(triangle.GetEdge(index), normal, frame, out Signed576 h, out Signed576 l);`
63	`260`	`if (SumProductSign(Extend(denominator), h, Extend(numerator), l) < 0)`
8	`261`	`return false;`
	`262`	`}`
15	`263`	`return true;`
	`264`	`}`
	`265`
	`266`	`private static bool ContainsStationaryPoint(FixedTriangle triangle, WideAxis3 normal, Signed320 normalSquared,`
	`267`	`in QueryFrame frame, Signed320 b, Signed320 c, Signed576 p, Fixed64 height, Fixed64 parameter)`
	`268`	`{`
105	`269`	`Signed832 originScale = Product(p, MaximumParameter, Scale);`
105	`270`	`Signed832 axisScale = WideArithmetic.SubtractSigned832(`
105	`271`	`Product(Signed576.ExtendValue(normalSquared), frame.AxisSquared, Signed192.Raw(height), Signed192.Raw(parame`
105	`272`	`Product(WideArithmetic.MultiplySigned320(b, c), MaximumParameter, Scale));`
724	`273`	`for (int index = 0; index < 3; index++)`
	`274`	`{`
284	`275`	`GetEdgeProducts(triangle.GetEdge(index), normal, frame, out Signed576 h, out Signed576 l);`
	`276`	`// These halfspace products can exceed 832 bits; compare magnitudes`
	`277`	`// in existing transient product storage rather than truncating.`
284	`278`	`if (SumProductSign(originScale, h, axisScale, l) < 0)`
27	`279`	`return false;`
	`280`	`}`
78	`281`	`return true;`
	`282`	`}`
	`283`
	`284`	`private static void GetEdgeProducts(FixedSegment edge, WideAxis3 normal, in QueryFrame frame, out Signed576 h, out S`
	`285`	`{`
347	`286`	`WideAxis3 inward = WideAxis3.Cross(normal, Difference(edge.End, edge.Start));`
347	`287`	`h = WideAxis3.Dot(inward, Subtract(frame.Apex, Multiply(Raw(edge.Start), frame.Denominator)));`
347	`288`	`l = WideAxis3.Dot(inward, frame.Axis);`
347	`289`	`}`
	`290`
	`291`	`private static Fixed64 WitnessCoordinate(Signed320 apex, Signed320 axis, Signed320 normal, Signed192 denominator,`
	`292`	`Signed320 q, Signed320 b, Signed320 c, Signed576 p, Fixed64 height, Fixed64 parameter)`
	`293`	`{`
171	`294`	`Signed576 v = WideArithmetic.SubtractSigned576(WideArithmetic.MultiplySigned320(q, normal), WideArithmetic.Multi`
171	`295`	`Signed832 w = WideArithmetic.SubtractSigned832(WideArithmetic.MultiplySigned576ToSigned832(p, axis),`
171	`296`	`WideArithmetic.MultiplySigned576ToSigned832(v, b));`
171	`297`	`Signed832 first = WideArithmetic.AddSigned832(WideArithmetic.MultiplySigned576ToSigned832(p, apex),`
171	`298`	`WideArithmetic.MultiplySigned576ToSigned832(v, c));`
171	`299`	`first = WideArithmetic.MultiplySigned832(WideArithmetic.MultiplySigned832(first, MaximumParameter), Scale);`
171	`300`	`Signed832 second = WideArithmetic.MultiplySigned832(WideArithmetic.MultiplySigned832(w, Signed192.Raw(height)),`
171	`301`	`return Ratio(WideArithmetic.AddSigned832(first, second), Product(p, denominator, MaximumParameter, Scale));`
	`302`	`}`
	`303`
	`304`	`private static Fixed64 AxisCoordinate(Signed320 apex, Signed320 axis, Signed192 frameD, Signed320 numerator, Signed3`
21	`305`	`Ratio(Signed832.ExtendValue(WideArithmetic.AddSigned576(WideArithmetic.MultiplySigned320(apex, denominator),`
21	`306`	`WideArithmetic.MultiplySigned320(axis, numerator))),`
21	`307`	`WideArithmetic.MultiplySigned832(Extend(denominator), frameD));`
	`308`
	`309`	`private static int SumProductSign(Signed832 a, Signed576 b, Signed832 c, Signed576 d)`
	`310`	`{`
694	`311`	`int first = a.Sign * b.Sign, second = c.Sign * d.Sign;`
361	`312`	`if (first == 0) return second;`
473	`313`	`if (second == 0 \|\| first == second) return first;`
193	`314`	`return first * WideArithmetic.CompareNonNegativeProducts(a, Signed832.ExtendValue(b), c, Signed832.ExtendValue(d`
	`315`	`}`
	`316`
	`317`	`private static Fixed64 Ratio(Signed832 numerator, Signed832 denominator)`
	`318`	`{`
199	`319`	`bool represented = Fixed64.TryGetSignedRawRatio(numerator, denominator, 0, out Fixed64 value);`
	`320`	`System.Diagnostics.Debug.Assert(represented);`
199	`321`	`return value;`
	`322`	`}`
	`323`
	`324`	`private static Signed832 Product(Signed576 value, Signed192 a, Signed192 b) =>`
934	`325`	`WideArithmetic.MultiplySigned832(WideArithmetic.MultiplySigned832(Signed832.ExtendValue(value), a), b);`
	`326`	`private static Signed832 Product(Signed576 value, Signed192 a, Signed192 b, Signed192 c) =>`
724	`327`	`WideArithmetic.MultiplySigned832(Product(value, a, b), c);`
	`328`	`private static Signed832 Product(Signed576 value, Signed192 a, Signed192 b, Signed192 c, Signed192 d) =>`
217	`329`	`WideArithmetic.MultiplySigned832(Product(value, a, b, c), d);`
	`330`	`private static Signed832 Product(Signed576 value, Signed192 a, Signed192 b, Signed192 c, Signed192 d, Signed192 e) =`
105	`331`	`WideArithmetic.MultiplySigned832(Product(value, a, b, c, d), e);`
161	`332`	`private static Signed832 Extend(Signed320 value) => Signed832.ExtendValue(Signed576.ExtendValue(value));`
1920	`333`	`private static Signed192 Narrow(Signed320 value) => Signed192.NarrowProven(value);`
1787	`334`	`private static WideAxis3 Axis(Signed192 x, Signed192 y, Signed192 z) => new(Signed320.ExtendValue(x), Signed320.Exte`
1042	`335`	`private static WideAxis3 Raw(Vector3d value) => Axis(Signed192.Raw(value.X), Signed192.Raw(value.Y), Signed192.Raw(v`
609	`336`	`private static WideAxis3 Difference(Vector3d a, Vector3d b) => Axis(WideArithmetic.Difference(a.X, b.X), WideArithme`
72	`337`	`private static WideAxis3 Add(WideAxis3 a, WideAxis3 b) => new(WideArithmetic.AddSigned320(a.X, b.X), WideArithmetic.`
499	`338`	`private static WideAxis3 Subtract(WideAxis3 a, WideAxis3 b) => new(WideArithmetic.SubtractSigned320(a.X, b.X), WideA`
568	`339`	`private static WideAxis3 Multiply(WideAxis3 value, Signed192 scale) => new(WideArithmetic.MultiplySigned192(Narrow(v`
709	`340`	`private static Signed320 Dot(WideAxis3 a, WideAxis3 b) => Signed320.NarrowValue(WideAxis3.Dot(a, b));`
	`341`	`}`

/home/runner/work/FixedMathSharp/FixedMathSharp/src/FixedMathSharp/Geometry/Wide/FiniteAxis/WideTriangleConeIntersection.ScaledFrame.cs

#	Line	Line coverage
	`1`	`//=======================================================================`
	`2`	`// WideTriangleConeIntersection.ScaledFrame.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>Exact source-frame ingress for finite triangle/cone minimum-axial queries.</content>`
	`13`	`internal static partial class WideTriangleConeIntersection`
	`14`	`{`
	`15`	`private const int ScaledQueryWords = 32;`
	`16`
	`17`	`internal static bool TryGetMinimumAxialPoint(in FixedTriangle triangle, in ScaledRigidFrame3d frame,`
	`18`	`Vector3d apex, Vector3d axis, Fixed64 height, Fixed64 radius,`
	`19`	`out FixedPointAnchor point)`
	`20`	`{`
30	`21`	`if (frame.IsRigid)`
	`22`	`{`
2	`23`	`bool found = TryGetMinimumAxialPoint(triangle,frame.RigidOrigin,frame.Rotation,apex,axis,height,radius,out V`
2	`24`	`point = found ? new FixedPointAnchor(frame.RigidOrigin,frame.Rotation,local) : default;`
2	`25`	`return found;`
	`26`	`}`
84	`27`	`bool hasPoint=false;point=default;Fixed64 best=Fixed64.MaxValue;`
224	`28`	`for(int edge=0;edge<3;edge++)`
	`29`	`{`
84	`30`	`if(!TryGetScaledConeEdgePoint(triangle.GetEdge(edge),frame,apex,axis,height,radius,out FixedPointAnchor cand`
27	`31`	`Fixed64 axial=GetScaledConeAxial(candidate,apex,axis,height);`
27	`32`	`if(hasPoint&&axial>=best)continue;`
45	`33`	`hasPoint=true;point=candidate;best=axial;`
	`34`	`}`
28	`35`	`if(TryGetScaledConeFacePoint(triangle,frame,apex,axis,height,radius,hasPoint,out FixedPointAnchor face,out Fixed`
40	`36`	`&&(!hasPoint\|\|faceAxial<best)){point=face;hasPoint=true;}`
28	`37`	`return hasPoint;`
	`38`	`}`
	`39`
	`40`	`private static Fixed64 GetScaledConeAxial(in FixedPointAnchor point,Vector3d apex,Vector3d axis,Fixed64 height) =>`
27	`41`	`FixedMath.Min(point.ProjectNonNegativeOffsetFrom(new FixedPointAnchor(apex,FixedQuaternion.Identity,Vector3d.Zer`
	`42`
273	`43`	`private static WideDirection3d GetScaledConeRelativePoint(in RationalPoint3d point,Vector3d apex) => new(`
273	`44`	`WideArithmetic.SubtractSigned576(Signed576.ExtendValue(point.X),WideArithmetic.MultiplySigned320(point.Denominat`
273	`45`	`WideArithmetic.SubtractSigned576(Signed576.ExtendValue(point.Y),WideArithmetic.MultiplySigned320(point.Denominat`
273	`46`	`WideArithmetic.SubtractSigned576(Signed576.ExtendValue(point.Z),WideArithmetic.MultiplySigned320(point.Denominat`
	`47`
	`48`	`private static bool TryGetScaledConeEdgePoint(in FixedSegment edge,in ScaledRigidFrame3d frame,`
	`49`	`Vector3d apex,Vector3d axis,Fixed64 height,Fixed64 radius,out FixedPointAnchor point)`
	`50`	`{`
84	`51`	`point=default;`
84	`52`	`WideDirection3d first=GetScaledConeRelativePoint(frame.GetPoint(edge.Start),apex);`
84	`53`	`WideDirection3d last=GetScaledConeRelativePoint(frame.GetPoint(edge.End),apex);`
84	`54`	`WideDirection3d delta=new(WideArithmetic.SubtractSigned576(last.X,first.X),`
84	`55`	`WideArithmetic.SubtractSigned576(last.Y,first.Y),WideArithmetic.SubtractSigned576(last.Z,first.Z));`
84	`56`	`var direction=new WideDirection3d(new WideAxis3(Signed320.ExtendValue(Signed192.Raw(axis.X)),`
84	`57`	`Signed320.ExtendValue(Signed192.Raw(axis.Y)),Signed320.ExtendValue(Signed192.Raw(axis.Z))));`
252	`58`	`Signed832 q=direction.SquaredLength, startAxial=WideDirection3d.Dot(first,direction), velocity=WideDirection3d.D`
168	`59`	`Signed832 start=WideArithmetic.MultiplySigned832(startAxial,Scale), end=WideArithmetic.MultiplySigned832(WideAri`
84	`60`	`Signed832 maximum=default;`
	`61`	`// The denominator may exceed192 after independent placement rotations.`
	`62`	`// Keep the complete product in the borrowed coefficient bank below.`
	`63`	`const int words=ScaledQueryWords;`
168	`64`	`Span<ulong> values=stackalloc ulong[14*words];Span<int> signs=stackalloc int[14];`
168	`65`	`var a=ContactQuadratic.At(values,signs,0,words);var b=ContactQuadratic.At(values,signs,1,words);`
168	`66`	`var c=ContactQuadratic.At(values,signs,2,words);var work=ContactQuadratic.At(values,signs,3,words);`
168	`67`	`var term=ContactQuadratic.At(values,signs,4,words);var axial=ContactQuadratic.At(values,signs,5,words);`
84	`68`	`var radial=ContactQuadratic.At(values,signs,6,words);`
168	`69`	`work.Set(q);ContactQuadratic.Scale(work,Signed576.ExtendValue(frame.Denominator),term);`
84	`70`	`ContactQuadratic.Scale(term,Signed576.ExtendValue(Signed192.Raw(height)),work);`
84	`71`	`maximum=PackScaledCone832(work);`
336	`72`	`Signed832 lowerN=default,lowerD=Signed832.ExtendValue(Signed192.One),upperN=lowerD,upperD=lowerD;`
84	`73`	`if(!WideTriangleRelations.ClipScaledHalfPlane(start,end,ref lowerN,ref lowerD,ref upperN,ref upperD)`
84	`74`	`\|\|!WideTriangleRelations.ClipScaledHalfPlane(WideArithmetic.SubtractSigned832(maximum,start),`
101	`75`	`WideArithmetic.SubtractSigned832(maximum,end),ref lowerN,ref lowerD,ref upperN,ref upperD))return false;`
67	`76`	`BuildScaledConeEdgeCoefficient(delta,delta,velocity,velocity,q,height,radius,a,work,term,axial,radial);`
67	`77`	`BuildScaledConeEdgeCoefficient(first,delta,startAxial,velocity,q,height,radius,b,work,term,axial,radial);`
67	`78`	`BuildScaledConeEdgeCoefficient(first,first,startAxial,startAxial,q,height,radius,c,work,term,axial,radial);`
67	`79`	`if(!WideFiniteConeIntersection.TrySolveBoundedUnitPolynomial(a,b,c,lowerN,lowerD,upperN,upperD,`
105	`80`	`Fixed64.MaxValue,out Fixed64 entry,out Fixed64 exit))return false;`
29	`81`	`Fixed64 parameter=velocity.Sign<0?exit:entry;`
58	`82`	`work.Set(Signed576.ExtendValue(Signed192.Raw(parameter)));term.Set(Signed576.ExtendValue(MaximumParameter));`
29	`83`	`return WideTriangleRelations.TryGetSegmentPointAnchor(frame,edge,work,term,apex,out point);`
	`84`	`}`
	`85`
	`86`	`private static void BuildScaledConeEdgeCoefficient(in WideDirection3d first,in WideDirection3d second,`
	`87`	`Signed832 firstAxial,Signed832 secondAxial,Signed832 q,Fixed64 height,Fixed64 radius,`
	`88`	`scoped ContactQuadratic output,scoped ContactQuadratic work,scoped ContactQuadratic term,`
	`89`	`scoped ContactQuadratic axial,scoped ContactQuadratic radial)`
	`90`	`{`
402	`91`	`work.Set(firstAxial);ContactQuadratic.Scale(work,secondAxial,axial);`
603	`92`	`work.Set(WideDirection3d.Dot(first,second));ContactQuadratic.Scale(work,q,radial);radial.Add(axial,-1);`
402	`93`	`ContactQuadratic.Scale(radial,q,work);ContactQuadratic.Scale(work,Signed576.ExtendValue(Signed192.Raw(height)),t`
201	`94`	`ContactQuadratic.Scale(term,Signed576.ExtendValue(Signed192.Raw(height)),output);`
402	`95`	`ContactQuadratic.Scale(axial,Signed576.ExtendValue(Scale),work);ContactQuadratic.Scale(work,Signed576.ExtendValu`
201	`96`	`ContactQuadratic.Scale(term,Signed576.ExtendValue(Signed192.Raw(radius)),work);`
402	`97`	`ContactQuadratic.Scale(work,Signed576.ExtendValue(Signed192.Raw(radius)),term);output.Add(term,-1);`
201	`98`	`}`
	`99`
	`100`	`private static bool TryGetScaledConeFacePoint(in FixedTriangle triangle,in ScaledRigidFrame3d frame,`
	`101`	`Vector3d apex,Vector3d axis,Fixed64 height,Fixed64 radius,bool hasEdge,`
	`102`	`out FixedPointAnchor point,out Fixed64 axial)`
	`103`	`{`
56	`104`	`point=default;axial=default;`
28	`105`	`WideDirection3d normal=WideTriangleRelations.GetScaledTriangleLocalNormal(triangle,frame).Transform(frame.Geomet`
29	`106`	`if(normal.IsZero)return false;`
27	`107`	`var direction=new WideDirection3d(new WideAxis3(Signed320.ExtendValue(Signed192.Raw(axis.X)),`
27	`108`	`Signed320.ExtendValue(Signed192.Raw(axis.Y)),Signed320.ExtendValue(Signed192.Raw(axis.Z))));`
54	`109`	`Signed832 normalSquare=normal.SquaredLength,alignment=WideDirection3d.Dot(normal,direction);`
27	`110`	`Signed832 plane=WideDirection3d.Dot(normal,GetScaledConeRelativePoint(frame.GetPoint(triangle.A),apex));`
27	`111`	`Signed832 q=direction.SquaredLength;`
	`112`	`const int words=ScaledQueryWords;`
54	`113`	`Span<ulong> values=stackalloc ulong[18*words];Span<int> signs=stackalloc int[18];`
54	`114`	`var a=ContactQuadratic.At(values,signs,0,words);var b=ContactQuadratic.At(values,signs,1,words);`
54	`115`	`var c=ContactQuadratic.At(values,signs,2,words);var p=ContactQuadratic.At(values,signs,3,words);`
54	`116`	`var work=ContactQuadratic.At(values,signs,4,words);var term=ContactQuadratic.At(values,signs,5,words);`
54	`117`	`var axisN=ContactQuadratic.At(values,signs,6,words);var axisD=ContactQuadratic.At(values,signs,7,words);`
27	`118`	`var ratio=ContactQuadratic.At(values,signs,8,words);`
54	`119`	`work.Set(normalSquare);ContactQuadratic.Scale(work,q,p);`
81	`120`	`work.Set(alignment);ContactQuadratic.Scale(work,alignment,term);p.Add(term,-1);`
81	`121`	`axisN.Set(plane);ContactQuadratic.Scale(axisN,Signed576.ExtendValue(Scale),work);work.CopyTo(axisN);`
54	`122`	`axisD.Set(alignment);ContactQuadratic.Scale(axisD,Signed576.ExtendValue(frame.Denominator),work);`
27	`123`	`ContactQuadratic.Scale(work,Signed576.ExtendValue(Signed192.Raw(height)),axisD);`
45	`124`	`if(axisD.Signs[0]<0){axisN.MultiplySign(-1);axisD.MultiplySign(-1);}`
27	`125`	`bool crossesAxis=axisD.Signs[0]!=0&&axisN.Signs[0]>=0`
27	`126`	`&&WideArithmetic.CompareMagnitudeEqualLength(axisN.Rational,axisD.Rational)<=0;`
27	`127`	`if(p.Signs[0]==0)`
	`128`	`{`
18	`129`	`if(hasEdge\|\|!crossesAxis)return false;`
6	`130`	`return TryGetScaledConeAxisPoint(triangle,frame,apex,axis,alignment,plane,true,out point,out axial);`
	`131`	`}`
45	`132`	`work.Set(alignment);ContactQuadratic.Scale(work,alignment,term);ContactQuadratic.Scale(term,q,a);`
15	`133`	`ContactQuadratic.Scale(a,Signed576.ExtendValue(Signed192.Raw(height)),work);`
15	`134`	`ContactQuadratic.Scale(work,Signed576.ExtendValue(Signed192.Raw(height)),a);`
15	`135`	`ContactQuadratic.Scale(p,Signed576.ExtendValue(Signed192.Raw(radius)),work);`
15	`136`	`ContactQuadratic.Scale(work,Signed576.ExtendValue(Signed192.Raw(radius)),term);`
45	`137`	`ContactQuadratic.Scale(term,Signed576.ExtendValue(Scale),work);ContactQuadratic.Scale(work,Signed576.ExtendValue`
30	`138`	`ContactQuadratic.Scale(a,Signed576.ExtendValue(frame.Denominator),work);ContactQuadratic.Scale(work,Signed576.Ex`
45	`139`	`work.Set(alignment);ContactQuadratic.Scale(work,plane,term);ContactQuadratic.Scale(term,q,b);`
30	`140`	`ContactQuadratic.Scale(b,Signed576.ExtendValue(Scale),work);ContactQuadratic.Scale(work,Signed576.ExtendValue(Si`
30	`141`	`ContactQuadratic.Scale(term,Signed576.ExtendValue(frame.Denominator),b);b.MultiplySign(-1);`
45	`142`	`work.Set(plane);ContactQuadratic.Scale(work,plane,term);ContactQuadratic.Scale(term,q,c);`
30	`143`	`ContactQuadratic.Scale(c,Signed576.ExtendValue(Scale),work);ContactQuadratic.Scale(work,Signed576.ExtendValue(Sc`
15	`144`	`Signed832 one=Signed832.ExtendValue(Signed192.One);`
17	`145`	`if(!WideFiniteConeIntersection.TrySolveBoundedUnitPolynomial(a,b,c,default,one,one,one,Fixed64.MaxValue,out Fixe`
13	`146`	`Signed832 pValue=PackScaledCone832(p);`
	`147`	`bool contained;`
13	`148`	`if(!hasEdge)`
	`149`	`{`
4	`150`	`contained=crossesAxis`
4	`151`	`?TryGetScaledConeAxisPoint(triangle,frame,apex,axis,alignment,plane,false,out _,out _)`
4	`152`	`:TryGetScaledConeStationaryPoint(triangle,frame,apex,axis,normal,normalSquare,alignment,plane,pValue,q,h`
	`153`	`}`
	`154`	`else`
	`155`	`{`
9	`156`	`int sign=WideFiniteConeIntersection.GetBorrowedPolynomialSignAtRationalParameter(a,b,c,`
9	`157`	`Signed832.ExtendValue(Signed192.Raw(entry)),Signed832.ExtendValue(MaximumParameter));`
9	`158`	`Fixed64 lower=sign<0?Fixed64.FromRaw(entry.m_rawValue-1):entry;`
9	`159`	`Fixed64 upper=sign>0?Fixed64.FromRaw(entry.m_rawValue+1):entry;`
9	`160`	`contained=TryGetScaledConeStationaryPoint(triangle,frame,apex,axis,normal,normalSquare,alignment,plane,pValu`
9	`161`	`&&(lower==upper\|\|TryGetScaledConeStationaryPoint(triangle,frame,apex,axis,normal,normalSquare,alignment,`
	`162`	`}`
21	`163`	`if(!contained\|\|!TryGetScaledConeStationaryPoint(triangle,frame,apex,axis,normal,normalSquare,alignment,plane,pVa`
10	`164`	`work.Set(Signed576.ExtendValue(Signed192.Raw(height)));ContactQuadratic.Scale(work,Signed576.ExtendValue(Signed1`
5	`165`	`work.Set(Signed576.ExtendValue(MaximumParameter));`
5	`166`	`axial=ContactQuadratic.RoundRatio(ratio,work,ReadOnlySpan<ulong>.Empty,0,height.m_rawValue);`
5	`167`	`return true;`
	`168`	`}`
	`169`
	`170`	`private static bool TryGetScaledConeAxisPoint(in FixedTriangle triangle,in ScaledRigidFrame3d frame,`
	`171`	`Vector3d apex,Vector3d axis,Signed832 alignment,Signed832 plane,bool materialize,`
	`172`	`out FixedPointAnchor point,out Fixed64 axial)`
	`173`	`{`
	`174`	`const int words=ScaledQueryWords;`
14	`175`	`Span<ulong> values=stackalloc ulong[10*words];Span<int> signs=stackalloc int[10];`
14	`176`	`var x=ContactQuadratic.At(values,signs,0,words);var y=ContactQuadratic.At(values,signs,1,words);`
14	`177`	`var z=ContactQuadratic.At(values,signs,2,words);var d=ContactQuadratic.At(values,signs,3,words);`
7	`178`	`var work=ContactQuadratic.At(values,signs,4,words);`
14	`179`	`work.Set(plane);ContactQuadratic.Scale(work,Signed576.ExtendValue(Signed192.Raw(axis.X)),x);`
7	`180`	`ContactQuadratic.Scale(work,Signed576.ExtendValue(Signed192.Raw(axis.Y)),y);`
7	`181`	`ContactQuadratic.Scale(work,Signed576.ExtendValue(Signed192.Raw(axis.Z)),z);`
14	`182`	`work.Set(alignment);ContactQuadratic.Scale(work,Signed576.ExtendValue(frame.Denominator),d);`
19	`183`	`if(d.Signs[0]<0){d.MultiplySign(-1);x.MultiplySign(-1);y.MultiplySign(-1);z.MultiplySign(-1);}`
14	`184`	`point=default;axial=default;`
9	`185`	`if(!ContainsScaledConeFacePoint(triangle,frame,apex,x,y,z,d))return false;`
6	`186`	`if(!materialize)return true;`
5	`187`	`if(!QuadraticPointMaterialization.TryGetPointInFrame(apex,FixedQuaternion.Identity,x,y,z,d,ReadOnlySpan<ulong>.E`
3	`188`	`point=new FixedPointAnchor(apex,FixedQuaternion.Identity,local);`
6	`189`	`work.Set(plane);ContactQuadratic.Scale(work,Signed576.ExtendValue(Scale),x);`
4	`190`	`if(alignment.Sign<0)x.MultiplySign(-1);`
3	`191`	`axial=ContactQuadratic.RoundRatio(x,d,ReadOnlySpan<ulong>.Empty,0,long.MaxValue);`
3	`192`	`return true;`
	`193`	`}`
	`194`
	`195`	`private static bool TryGetScaledConeStationaryPoint(in FixedTriangle triangle,in ScaledRigidFrame3d frame,`
	`196`	`Vector3d apex,Vector3d axis,in WideDirection3d normal,Signed832 normalSquare,Signed832 alignment,`
	`197`	`Signed832 plane,Signed832 p,Signed832 q,Fixed64 height,Fixed64 parameter,bool materialize,out FixedPointAnchor p`
	`198`	`{`
	`199`	`const int words=ScaledQueryWords;`
44	`200`	`Span<ulong> values=stackalloc ulong[16*words];Span<int> signs=stackalloc int[16];`
44	`201`	`var x=ContactQuadratic.At(values,signs,0,words);var y=ContactQuadratic.At(values,signs,1,words);`
44	`202`	`var z=ContactQuadratic.At(values,signs,2,words);var d=ContactQuadratic.At(values,signs,3,words);`
44	`203`	`var work=ContactQuadratic.At(values,signs,4,words);var term=ContactQuadratic.At(values,signs,5,words);`
44	`204`	`var w=ContactQuadratic.At(values,signs,6,words);var v=ContactQuadratic.At(values,signs,7,words);`
44	`205`	`work.Set(p);ContactQuadratic.Scale(work,Signed576.ExtendValue(frame.Denominator),term);`
44	`206`	`ContactQuadratic.Scale(term,Signed576.ExtendValue(Scale),work);ContactQuadratic.Scale(work,Signed576.ExtendValue`
176	`207`	`for(int coordinate=0;coordinate<3;coordinate++)`
	`208`	`{`
66	`209`	`var output=coordinate==0?x:coordinate==1?y:z;`
66	`210`	`Signed576 n=coordinate==0?normal.X:coordinate==1?normal.Y:normal.Z;`
132	`211`	`work.Set(normalSquare);ContactQuadratic.Scale(work,Signed576.ExtendValue(Signed192.Raw(axis[coordinate])),w)`
198	`212`	`work.Set(alignment);ContactQuadratic.Scale(work,n,term);w.Add(term,-1);`
132	`213`	`work.Set(q);ContactQuadratic.Scale(work,n,v);`
198	`214`	`work.Set(alignment);ContactQuadratic.Scale(work,Signed576.ExtendValue(Signed192.Raw(axis[coordinate])),term)`
132	`215`	`ContactQuadratic.Scale(w,q,work);ContactQuadratic.Scale(work,Signed576.ExtendValue(Signed192.Raw(height)),te`
132	`216`	`ContactQuadratic.Scale(term,Signed576.ExtendValue(frame.Denominator),work);ContactQuadratic.Scale(work,Signe`
132	`217`	`ContactQuadratic.Scale(v,plane,work);ContactQuadratic.Scale(work,Signed576.ExtendValue(Scale),term);`
132	`218`	`ContactQuadratic.Scale(term,Signed576.ExtendValue(MaximumParameter),work);output.Add(work);`
	`219`	`}`
22	`220`	`point=default;`
29	`221`	`if(!ContainsScaledConeFacePoint(triangle,frame,apex,x,y,z,d))return false;`
24	`222`	`if(!materialize)return true;`
7	`223`	`if(!QuadraticPointMaterialization.TryGetPointInFrame(apex,FixedQuaternion.Identity,x,y,z,d,ReadOnlySpan<ulong>.E`
10	`224`	`point=new FixedPointAnchor(apex,FixedQuaternion.Identity,local);return true;`
	`225`	`}`
	`226`
	`227`	`private static bool ContainsScaledConeFacePoint(in FixedTriangle triangle,in ScaledRigidFrame3d frame,Vector3d apex,`
	`228`	`scoped ContactQuadratic x,scoped ContactQuadratic y,scoped ContactQuadratic z,scoped ContactQuadratic denominato`
	`229`	`{`
	`230`	`const int words=ScaledQueryWords;`
58	`231`	`Span<ulong> values=stackalloc ulong[8*words];Span<int> signs=stackalloc int[8];`
58	`232`	`var sum=ContactQuadratic.At(values,signs,0,words);var delta=ContactQuadratic.At(values,signs,1,words);`
58	`233`	`var term=ContactQuadratic.At(values,signs,2,words);var product=ContactQuadratic.At(values,signs,3,words);`
29	`234`	`WideDirection3d normal=WideTriangleRelations.GetScaledTriangleLocalNormal(triangle,frame);`
196	`235`	`for(int edge=0;edge<3;edge++)`
	`236`	`{`
78	`237`	`FixedSegment segment=triangle.GetEdge(edge);`
78	`238`	`WideDirection3d inward=WideDirection3d.Cross(normal,WideDirection3d.GetLocalEdge(frame,segment.Start,segment`
156	`239`	`WideDirection3d start=GetScaledConeRelativePoint(frame.GetPoint(segment.Start),apex);sum.Clear();`
624	`240`	`for(int coordinate=0;coordinate<3;coordinate++)`
	`241`	`{`
234	`242`	`var point=coordinate==0?x:coordinate==1?y:z;`
234	`243`	`ContactQuadratic.Scale(point,Signed576.ExtendValue(frame.Denominator),delta);`
468	`244`	`ContactQuadratic.Scale(denominator,coordinate==0?start.X:coordinate==1?start.Y:start.Z,term);delta.Add(t`
468	`245`	`ContactQuadratic.Scale(delta,coordinate==0?inward.X:coordinate==1?inward.Y:inward.Z,product);sum.Add(pro`
	`246`	`}`
87	`247`	`if(sum.Signs[0]<0)return false;`
	`248`	`}`
20	`249`	`return true;`
	`250`	`}`
	`251`
	`252`	`private static Signed832 PackScaledCone832(scoped ContactQuadratic value)`
	`253`	`{`
	`254`	`// Both callers pack nonnegative values: the positive axial cap and`
	`255`	`// the Gram minor \|normal\|²\|axis\|²-(normal.axis)².`
	`256`	`System.Diagnostics.Debug.Assert(value.Signs[0]>=0);`
291	`257`	`Span<ulong> data=stackalloc ulong[13];data.Clear();value.Rational[..WideArithmetic.GetActiveMagnitudeLength(valu`
97	`258`	`return new Signed832(data[12],data[11],data[10],data[9],data[8],data[7],data[6],data[5],data[4],data[3],data[2],`
	`259`	`}`
	`260`	`}`

Methods/Properties