< Summary

Information

Class:	Gravitas.CollisionHandling.ExactContactResponseKernel
Assembly:	Gravitas
File(s):	File 1: /home/runner/work/Gravitas/Gravitas/src/Gravitas/CollisionHandling/Response/Exact/ExactContactResponseKernel.Coulomb.cs File 2: /home/runner/work/Gravitas/Gravitas/src/Gravitas/CollisionHandling/Response/Exact/ExactContactResponseKernel.CoulombDiskCache.cs File 3: /home/runner/work/Gravitas/Gravitas/src/Gravitas/CollisionHandling/Response/Exact/ExactContactResponseKernel.Normal.cs

Line coverage

100%

Covered lines:	1950
Uncovered lines:	0
Coverable lines:	1950
Total lines:	2718
Line coverage:	100%

Branch coverage

100%

Covered branches:	230
Total branches:	230
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: TryGetCoulombLineResponse(...)	100%	12	12	100%
File 1: TryGetCoulombDiskResponse(...)	100%	4	4	100%
File 1: TryGetCoulombDiskResponse(...)	100%	4	4	100%
File 1: TryGetCoulombDiskResponseCore(...)	100%	26	26	100%
File 1: AreCoulombDiskInputsValid(...)	100%	1	1	100%
File 1: TryGetCompletedNormalAccumulatorRatio(...)	100%	16	16	100%
File 1: GetBilateralImpulseRatio(...)	100%	10	10	100%
File 1: GetFrictionLimit(...)	100%	1	1	100%
File 1: AddFixedToRatio(...)	100%	4	4	100%
File 1: SubtractFixedFromRatio(...)	100%	4	4	100%
File 1: CompareRatios(...)	100%	1	1	100%
File 1: IsVectorWithinLimit(...)	100%	1	1	100%
File 1: AddSignedMagnitudes(...)	100%	4	4	100%
File 1: TryGetSignedRatioOverSquareRoot(...)	100%	14	14	100%
File 1: CompareRatioOverSquareRoot(...)	100%	1	1	100%
File 1: CompareRatioOverSquareRoot(...)	100%	1	1	100%
File 1: HaveMatchingParticipants(...)	100%	1	1	100%
File 2: IsRadialProjectionEqualToFixed(...)	100%	4	4	100%
File 2: TryGetSignedRadicalAndRationalSum(...)	100%	22	22	100%
File 2: CompareSignedRadicalAndRationalSumToMagnitude(...)	100%	1	1	100%
File 2: CompareSignedRadicalAndRationalSumToMagnitude(...)	100%	1	1	100%
File 2: GetWeightedFixedSum(...)	100%	1	1	100%
File 2: GetWeightedSignedWideSum(...)	100%	1	1	100%
File 2: GetProductSign(...)	100%	1	1	100%
File 2: TrimMagnitude(...)	100%	4	4	100%
File 2: TryGetDiskVelocityDeltas(...)	100%	1	1	100%
File 2: TryGetDiskLinearVelocityDelta(...)	100%	2	2	100%
File 2: TryGetDiskLinearComponent(...)	100%	6	6	100%
File 2: TryGetDiskAngularVelocityDelta(...)	100%	2	2	100%
File 2: TryGetDiskAngularComponent(...)	100%	4	4	100%
File 2: GetWeightedSignedSum(...)	100%	8	8	100%
File 3: TryGetNormalResponse(...)	100%	1	1	100%
File 3: TryGetAccumulatedNormalResponse(...)	100%	1	1	100%
File 3: TryGetNormalResponseCore(...)	100%	42	42	100%
File 3: CreateZeroResponse(...)	100%	1	1	100%
File 3: GetEffectiveMassRatio(...)	100%	8	8	100%
File 3: BuildImpulseRatio(...)	100%	1	1	100%
File 3: ResolveUnilateralImpulse(...)	100%	12	12	100%
File 3: TryGetLinearVelocityDelta(...)	100%	8	8	100%
File 3: TryGetLinearComponent(...)	100%	2	2	100%
File 3: TryGetAngularVelocityDelta(...)	100%	4	4	100%
File 3: TryGetAngularComponent(...)	100%	2	2	100%
File 3: GetRawDot(...)	100%	1	1	100%
File 3: SetNonNegativeRatio(...)	100%	2	2	100%
File 3: SetUnsignedSum(...)	100%	1	1	100%
File 3: SetMagnitude(...)	100%	1	1	100%
File 3: SetMagnitude(...)	100%	1	1	100%
File 3: SetMagnitude(...)	100%	1	1	100%
File 3: SetMagnitude(...)	100%	1	1	100%
File 3: SetMagnitude(...)	100%	1	1	100%
File 3: Multiply3(...)	100%	1	1	100%
File 3: Multiply4(...)	100%	1	1	100%

File(s)

/home/runner/work/Gravitas/Gravitas/src/Gravitas/CollisionHandling/Response/Exact/ExactContactResponseKernel.Coulomb.cs

#	Line	Line coverage
	`1`	`//=======================================================================`
	`2`	`// ExactContactResponseKernel.Coulomb.cs`
	`3`	`//=======================================================================`
	`4`	`// MIT License, Copyright (c) 2026-present David Oravsky (mrdav30)`
	`5`	`// See LICENSE file in the project root for full license information.`
	`6`	`//=======================================================================`
	`7`
	`8`	`using System;`
	`9`	`using System.Runtime.CompilerServices;`
	`10`
	`11`	`using FixedMathSharp;`
	`12`	`using FixedMathSharp.Geometry;`
	`13`
	`14`	`namespace Gravitas.CollisionHandling;`
	`15`
	`16`	`/// <content>`
	`17`	`/// Owns exact line and disk Coulomb-friction policy and materialization.`
	`18`	`/// </content>`
	`19`	`internal static partial class ExactContactResponseKernel`
	`20`	`{`
	`21`	`private const int MaxCoulombWords = MaxResponseWords * 2;`
	`22`	`private const int MaxCoulombSquareWords = MaxCoulombWords * 2;`
	`23`	`// Normal-response ratios use fewer than 46 active words. A common tangent`
	`24`	`// denominator therefore uses fewer than 92, its squared magnitude fewer`
	`25`	`// than 185 including carry, and the largest radial comparison fewer than`
	`26`	`// 307. The remaining words prevent silent product truncation.`
	`27`	`private const int MaxCoulombComparisonWords = 320;`
	`28`
	`29`	`[MethodImpl(MethodImplOptions.NoInlining)]`
	`30`	`internal static bool TryGetCoulombLineResponse(`
	`31`	`in ExactNormalConstraint3D normalConstraint,`
	`32`	`in ExactContactResponseOperand3D firstTangent,`
	`33`	`in ExactContactResponseOperand3D secondTangent,`
	`34`	`Vector3d tangent,`
	`35`	`Fixed64 accumulatedTangentImpulse,`
	`36`	`Fixed64 staticFriction,`
	`37`	`Fixed64 dynamicFriction,`
	`38`	`out ExactCoulombResponse3D response)`
	`39`	`{`
59	`40`	`response = default;`
59	`41`	`bool inputsValid =`
59	`42`	`staticFriction >= Fixed64.Zero`
59	`43`	`& dynamicFriction >= Fixed64.Zero`
59	`44`	`& tangent.IsNormalized();`
59	`45`	`if (!inputsValid)`
3	`46`	`return false;`
	`47`
56	`48`	`bool constraintValid =`
56	`49`	`FixedMath.Abs(Vector3d.Dot(`
56	`50`	`normalConstraint.Normal,`
56	`51`	`tangent)) <= Fixed64.Epsilon`
56	`52`	`& HaveMatchingParticipants(`
56	`53`	`normalConstraint.First,`
56	`54`	`firstTangent)`
56	`55`	`& HaveMatchingParticipants(`
56	`56`	`normalConstraint.Second,`
56	`57`	`secondTangent);`
56	`58`	`if (!constraintValid)`
2	`59`	`return false;`
	`60`
54	`61`	`Span<ulong> normalNumerator = stackalloc ulong[MaxResponseWords];`
54	`62`	`Span<ulong> normalDenominator = stackalloc ulong[MaxResponseWords];`
54	`63`	`Span<ulong> tangentNumerator = stackalloc ulong[MaxResponseWords];`
54	`64`	`Span<ulong> tangentDenominator = stackalloc ulong[MaxResponseWords];`
54	`65`	`if (!TryGetCompletedNormalAccumulatorRatio(`
54	`66`	`normalConstraint,`
54	`67`	`normalNumerator,`
54	`68`	`normalDenominator))`
1	`69`	`return false;`
53	`70`	`GetBilateralImpulseRatio(`
53	`71`	`firstTangent,`
53	`72`	`secondTangent,`
53	`73`	`tangent,`
53	`74`	`Fixed64.Zero,`
53	`75`	`tangentNumerator,`
53	`76`	`tangentDenominator,`
53	`77`	`out int tangentSign);`
	`78`
53	`79`	`Span<ulong> desiredNumerator = stackalloc ulong[MaxResponseWords];`
53	`80`	`AddFixedToRatio(`
53	`81`	`tangentNumerator,`
53	`82`	`tangentDenominator,`
53	`83`	`tangentSign,`
53	`84`	`accumulatedTangentImpulse,`
53	`85`	`desiredNumerator,`
53	`86`	`out int desiredSign);`
	`87`
53	`88`	`Span<ulong> staticNumerator = stackalloc ulong[MaxResponseWords];`
53	`89`	`Span<ulong> staticDenominator = stackalloc ulong[MaxResponseWords];`
53	`90`	`GetFrictionLimit(`
53	`91`	`normalNumerator,`
53	`92`	`normalDenominator,`
53	`93`	`staticFriction,`
53	`94`	`staticNumerator,`
53	`95`	`staticDenominator);`
	`96`
53	`97`	`Span<ulong> appliedNumerator = stackalloc ulong[MaxCoulombWords];`
53	`98`	`Span<ulong> appliedDenominator = stackalloc ulong[MaxCoulombWords];`
	`99`	`int appliedSign;`
53	`100`	`Span<ulong> accumulatedNumerator = stackalloc ulong[MaxCoulombWords];`
53	`101`	`Span<ulong> accumulatedDenominator = stackalloc ulong[MaxCoulombWords];`
	`102`	`int accumulatedSign;`
53	`103`	`appliedNumerator.Clear();`
53	`104`	`appliedDenominator.Clear();`
53	`105`	`accumulatedNumerator.Clear();`
53	`106`	`accumulatedDenominator.Clear();`
53	`107`	`Span<ulong> clampedNumerator = stackalloc ulong[MaxCoulombWords];`
53	`108`	`Span<ulong> clampedDenominator = stackalloc ulong[MaxResponseWords];`
53	`109`	`if (CompareRatios(`
53	`110`	`desiredNumerator,`
53	`111`	`tangentDenominator,`
53	`112`	`staticNumerator,`
53	`113`	`staticDenominator) <= 0)`
	`114`	`{`
37	`115`	`tangentNumerator.CopyTo(appliedNumerator);`
37	`116`	`tangentDenominator.CopyTo(appliedDenominator);`
37	`117`	`appliedSign = tangentSign;`
37	`118`	`desiredNumerator.CopyTo(accumulatedNumerator);`
37	`119`	`tangentDenominator.CopyTo(accumulatedDenominator);`
37	`120`	`accumulatedSign = desiredSign;`
	`121`	`}`
	`122`	`else`
	`123`	`{`
16	`124`	`GetFrictionLimit(`
16	`125`	`normalNumerator,`
16	`126`	`normalDenominator,`
16	`127`	`dynamicFriction,`
16	`128`	`clampedNumerator,`
16	`129`	`clampedDenominator);`
16	`130`	`clampedNumerator.CopyTo(accumulatedNumerator);`
16	`131`	`clampedDenominator.CopyTo(accumulatedDenominator);`
16	`132`	`accumulatedSign = WideArithmetic.IsZeroMagnitude(`
16	`133`	`clampedNumerator)`
16	`134`	`? 0`
16	`135`	`: desiredSign;`
16	`136`	`SubtractFixedFromRatio(`
16	`137`	`clampedNumerator,`
16	`138`	`clampedDenominator,`
16	`139`	`accumulatedSign,`
16	`140`	`accumulatedTangentImpulse,`
16	`141`	`appliedNumerator,`
16	`142`	`appliedDenominator,`
16	`143`	`out appliedSign);`
	`144`	`}`
	`145`
53	`146`	`bool resolved = TryGetLinearVelocityDelta(`
53	`147`	`firstTangent.LinearImpulseAxis,`
53	`148`	`firstTangent.InverseMass,`
53	`149`	`appliedNumerator,`
53	`150`	`appliedDenominator,`
53	`151`	`appliedSign,`
53	`152`	`out Vector3d firstLinear);`
53	`153`	`resolved &= TryGetAngularVelocityDelta(`
53	`154`	`firstTangent.Lever,`
53	`155`	`-tangent,`
53	`156`	`firstTangent.InverseInertia,`
53	`157`	`appliedNumerator,`
53	`158`	`appliedDenominator,`
53	`159`	`appliedSign,`
53	`160`	`out Vector3d firstAngular);`
53	`161`	`resolved &= TryGetLinearVelocityDelta(`
53	`162`	`secondTangent.LinearImpulseAxis,`
53	`163`	`secondTangent.InverseMass,`
53	`164`	`appliedNumerator,`
53	`165`	`appliedDenominator,`
53	`166`	`appliedSign,`
53	`167`	`out Vector3d secondLinear);`
53	`168`	`resolved &= TryGetAngularVelocityDelta(`
53	`169`	`secondTangent.Lever,`
53	`170`	`tangent,`
53	`171`	`secondTangent.InverseInertia,`
53	`172`	`appliedNumerator,`
53	`173`	`appliedDenominator,`
53	`174`	`appliedSign,`
53	`175`	`out Vector3d secondAngular);`
53	`176`	`if (!resolved)`
3	`177`	`return false;`
	`178`
50	`179`	`bool hasAccumulatedProjection = Fixed64.TryGetSignedRawRatio(`
50	`180`	`accumulatedNumerator,`
50	`181`	`accumulatedDenominator,`
50	`182`	`accumulatedSign < 0,`
50	`183`	`out Fixed64 accumulatedProjection);`
50	`184`	`response = new ExactCoulombResponse3D(`
50	`185`	`!WideArithmetic.IsZeroMagnitude(appliedNumerator),`
50	`186`	`firstLinear,`
50	`187`	`firstAngular,`
50	`188`	`secondLinear,`
50	`189`	`secondAngular,`
50	`190`	`hasAccumulatedProjection,`
50	`191`	`accumulatedProjection,`
50	`192`	`hasSecondaryAccumulatedImpulse: false,`
50	`193`	`secondaryAccumulatedImpulse: default);`
50	`194`	`return true;`
	`195`	`}`
	`196`
	`197`	`[MethodImpl(MethodImplOptions.NoInlining)]`
	`198`	`internal static bool TryGetCoulombDiskResponse(`
	`199`	`Vector3d normal,`
	`200`	`Fixed64 completedNormalImpulse,`
	`201`	`in ExactContactResponseOperand3D primaryFirst,`
	`202`	`in ExactContactResponseOperand3D primarySecond,`
	`203`	`Vector3d primaryTangent,`
	`204`	`Fixed64 accumulatedPrimaryTangentImpulse,`
	`205`	`in ExactContactResponseOperand3D secondaryFirst,`
	`206`	`in ExactContactResponseOperand3D secondarySecond,`
	`207`	`Vector3d secondaryTangent,`
	`208`	`Fixed64 accumulatedSecondaryTangentImpulse,`
	`209`	`Fixed64 staticFriction,`
	`210`	`Fixed64 dynamicFriction,`
	`211`	`out ExactCoulombResponse3D response)`
	`212`	`{`
386	`213`	`response = default;`
386	`214`	`if (completedNormalImpulse < Fixed64.Zero`
386	`215`	`\|\| !AreCoulombDiskInputsValid(`
386	`216`	`normal,`
386	`217`	`primaryFirst,`
386	`218`	`primarySecond,`
386	`219`	`primaryTangent,`
386	`220`	`secondaryFirst,`
386	`221`	`secondarySecond,`
386	`222`	`secondaryTangent,`
386	`223`	`staticFriction,`
386	`224`	`dynamicFriction))`
	`225`	`{`
2	`226`	`return false;`
	`227`	`}`
	`228`
384	`229`	`Span<ulong> normalNumerator = stackalloc ulong[MaxResponseWords];`
384	`230`	`Span<ulong> normalDenominator = stackalloc ulong[MaxResponseWords];`
384	`231`	`SetMagnitude(completedNormalImpulse, normalNumerator);`
384	`232`	`normalDenominator.Clear();`
384	`233`	`normalDenominator[0] = 1UL;`
384	`234`	`return TryGetCoulombDiskResponseCore(`
384	`235`	`normalNumerator,`
384	`236`	`normalDenominator,`
384	`237`	`primaryFirst,`
384	`238`	`primarySecond,`
384	`239`	`primaryTangent,`
384	`240`	`accumulatedPrimaryTangentImpulse,`
384	`241`	`secondaryFirst,`
384	`242`	`secondarySecond,`
384	`243`	`secondaryTangent,`
384	`244`	`accumulatedSecondaryTangentImpulse,`
384	`245`	`staticFriction,`
384	`246`	`dynamicFriction,`
384	`247`	`Fixed64.Epsilon,`
384	`248`	`out response);`
	`249`	`}`
	`250`
	`251`	`[MethodImpl(MethodImplOptions.NoInlining)]`
	`252`	`internal static bool TryGetCoulombDiskResponse(`
	`253`	`in ExactNormalConstraint3D normalConstraint,`
	`254`	`in ExactContactResponseOperand3D primaryFirst,`
	`255`	`in ExactContactResponseOperand3D primarySecond,`
	`256`	`Vector3d primaryTangent,`
	`257`	`Fixed64 accumulatedPrimaryTangentImpulse,`
	`258`	`in ExactContactResponseOperand3D secondaryFirst,`
	`259`	`in ExactContactResponseOperand3D secondarySecond,`
	`260`	`Vector3d secondaryTangent,`
	`261`	`Fixed64 accumulatedSecondaryTangentImpulse,`
	`262`	`Fixed64 staticFriction,`
	`263`	`Fixed64 dynamicFriction,`
	`264`	`out ExactCoulombResponse3D response)`
	`265`	`{`
59	`266`	`response = default;`
59	`267`	`bool inputsValid = AreCoulombDiskInputsValid(`
59	`268`	`normalConstraint.Normal,`
59	`269`	`primaryFirst,`
59	`270`	`primarySecond,`
59	`271`	`primaryTangent,`
59	`272`	`secondaryFirst,`
59	`273`	`secondarySecond,`
59	`274`	`secondaryTangent,`
59	`275`	`staticFriction,`
59	`276`	`dynamicFriction)`
59	`277`	`& HaveMatchingParticipants(`
59	`278`	`normalConstraint.First,`
59	`279`	`primaryFirst)`
59	`280`	`& HaveMatchingParticipants(`
59	`281`	`normalConstraint.Second,`
59	`282`	`primarySecond)`
59	`283`	`& HaveMatchingParticipants(primaryFirst, secondaryFirst)`
59	`284`	`& HaveMatchingParticipants(primarySecond, secondarySecond);`
59	`285`	`if (!inputsValid)`
3	`286`	`return false;`
	`287`
56	`288`	`Span<ulong> normalNumerator = stackalloc ulong[MaxResponseWords];`
56	`289`	`Span<ulong> normalDenominator = stackalloc ulong[MaxResponseWords];`
56	`290`	`if (!TryGetCompletedNormalAccumulatorRatio(`
56	`291`	`normalConstraint,`
56	`292`	`normalNumerator,`
56	`293`	`normalDenominator))`
1	`294`	`return false;`
	`295`
55	`296`	`return TryGetCoulombDiskResponseCore(`
55	`297`	`normalNumerator,`
55	`298`	`normalDenominator,`
55	`299`	`primaryFirst,`
55	`300`	`primarySecond,`
55	`301`	`primaryTangent,`
55	`302`	`accumulatedPrimaryTangentImpulse,`
55	`303`	`secondaryFirst,`
55	`304`	`secondarySecond,`
55	`305`	`secondaryTangent,`
55	`306`	`accumulatedSecondaryTangentImpulse,`
55	`307`	`staticFriction,`
55	`308`	`dynamicFriction,`
55	`309`	`Fixed64.Zero,`
55	`310`	`out response);`
	`311`	`}`
	`312`
	`313`	`private static bool TryGetCoulombDiskResponseCore(`
	`314`	`ReadOnlySpan<ulong> normalNumerator,`
	`315`	`ReadOnlySpan<ulong> normalDenominator,`
	`316`	`in ExactContactResponseOperand3D primaryFirst,`
	`317`	`in ExactContactResponseOperand3D primarySecond,`
	`318`	`Vector3d primaryTangent,`
	`319`	`Fixed64 accumulatedPrimaryTangentImpulse,`
	`320`	`in ExactContactResponseOperand3D secondaryFirst,`
	`321`	`in ExactContactResponseOperand3D secondarySecond,`
	`322`	`Vector3d secondaryTangent,`
	`323`	`Fixed64 accumulatedSecondaryTangentImpulse,`
	`324`	`Fixed64 staticFriction,`
	`325`	`Fixed64 dynamicFriction,`
	`326`	`Fixed64 velocityDeadzone,`
	`327`	`out ExactCoulombResponse3D response)`
	`328`	`{`
439	`329`	`response = default;`
439	`330`	`Span<ulong> primaryNumerator = stackalloc ulong[MaxResponseWords];`
439	`331`	`Span<ulong> primaryDenominator = stackalloc ulong[MaxResponseWords];`
439	`332`	`Span<ulong> secondaryNumerator = stackalloc ulong[MaxResponseWords];`
439	`333`	`Span<ulong> secondaryDenominator = stackalloc ulong[MaxResponseWords];`
439	`334`	`GetBilateralImpulseRatio(`
439	`335`	`primaryFirst,`
439	`336`	`primarySecond,`
439	`337`	`primaryTangent,`
439	`338`	`velocityDeadzone,`
439	`339`	`primaryNumerator,`
439	`340`	`primaryDenominator,`
439	`341`	`out int primarySign);`
439	`342`	`GetBilateralImpulseRatio(`
439	`343`	`secondaryFirst,`
439	`344`	`secondarySecond,`
439	`345`	`secondaryTangent,`
439	`346`	`velocityDeadzone,`
439	`347`	`secondaryNumerator,`
439	`348`	`secondaryDenominator,`
439	`349`	`out int secondarySign);`
	`350`
439	`351`	`Span<ulong> desiredPrimaryNumerator =`
439	`352`	`stackalloc ulong[MaxResponseWords];`
439	`353`	`Span<ulong> desiredSecondaryNumerator =`
439	`354`	`stackalloc ulong[MaxResponseWords];`
439	`355`	`AddFixedToRatio(`
439	`356`	`primaryNumerator,`
439	`357`	`primaryDenominator,`
439	`358`	`primarySign,`
439	`359`	`accumulatedPrimaryTangentImpulse,`
439	`360`	`desiredPrimaryNumerator,`
439	`361`	`out int desiredPrimarySign);`
439	`362`	`AddFixedToRatio(`
439	`363`	`secondaryNumerator,`
439	`364`	`secondaryDenominator,`
439	`365`	`secondarySign,`
439	`366`	`accumulatedSecondaryTangentImpulse,`
439	`367`	`desiredSecondaryNumerator,`
439	`368`	`out int desiredSecondarySign);`
	`369`
439	`370`	`Span<ulong> commonDenominator = stackalloc ulong[MaxCoulombWords];`
439	`371`	`Span<ulong> primaryAtCommon = stackalloc ulong[MaxCoulombWords];`
439	`372`	`Span<ulong> secondaryAtCommon = stackalloc ulong[MaxCoulombWords];`
439	`373`	`WideArithmetic.MultiplyMagnitudes(`
439	`374`	`primaryDenominator,`
439	`375`	`secondaryDenominator,`
439	`376`	`commonDenominator);`
439	`377`	`WideArithmetic.MultiplyMagnitudes(`
439	`378`	`desiredPrimaryNumerator,`
439	`379`	`secondaryDenominator,`
439	`380`	`primaryAtCommon);`
439	`381`	`WideArithmetic.MultiplyMagnitudes(`
439	`382`	`desiredSecondaryNumerator,`
439	`383`	`primaryDenominator,`
439	`384`	`secondaryAtCommon);`
	`385`
439	`386`	`Span<ulong> magnitudeSquared = stackalloc ulong[MaxCoulombSquareWords];`
439	`387`	`Span<ulong> square = stackalloc ulong[MaxCoulombSquareWords];`
439	`388`	`WideArithmetic.MultiplyMagnitudes(`
439	`389`	`primaryAtCommon,`
439	`390`	`primaryAtCommon,`
439	`391`	`magnitudeSquared);`
439	`392`	`WideArithmetic.MultiplyMagnitudes(`
439	`393`	`secondaryAtCommon,`
439	`394`	`secondaryAtCommon,`
439	`395`	`square);`
439	`396`	`WideArithmetic.AddMagnitudeInto(square, magnitudeSquared);`
	`397`
439	`398`	`Span<ulong> staticNumerator = stackalloc ulong[MaxResponseWords];`
439	`399`	`Span<ulong> staticDenominator = stackalloc ulong[MaxResponseWords];`
439	`400`	`GetFrictionLimit(`
439	`401`	`normalNumerator,`
439	`402`	`normalDenominator,`
439	`403`	`staticFriction,`
439	`404`	`staticNumerator,`
439	`405`	`staticDenominator);`
439	`406`	`bool withinStaticLimit = IsVectorWithinLimit(`
439	`407`	`magnitudeSquared,`
439	`408`	`commonDenominator,`
439	`409`	`staticNumerator,`
439	`410`	`staticDenominator);`
	`411`
439	`412`	`Span<ulong> dynamicNumerator = stackalloc ulong[MaxResponseWords];`
439	`413`	`Span<ulong> dynamicDenominator = stackalloc ulong[MaxResponseWords];`
439	`414`	`if (!withinStaticLimit)`
	`415`	`{`
225	`416`	`GetFrictionLimit(`
225	`417`	`normalNumerator,`
225	`418`	`normalDenominator,`
225	`419`	`dynamicFriction,`
225	`420`	`dynamicNumerator,`
225	`421`	`dynamicDenominator);`
	`422`	`}`
	`423`
439	`424`	`bool useDynamicProjection =`
439	`425`	`!withinStaticLimit`
439	`426`	`&& !WideArithmetic.IsZeroMagnitude(magnitudeSquared)`
439	`427`	`&& !WideArithmetic.IsZeroMagnitude(dynamicNumerator);`
	`428`	`bool hasAppliedImpulse;`
	`429`	`bool resolved;`
	`430`	`Vector3d firstLinear;`
	`431`	`Vector3d firstAngular;`
	`432`	`Vector3d secondLinear;`
	`433`	`Vector3d secondAngular;`
439	`434`	`if (useDynamicProjection)`
	`435`	`{`
217	`436`	`hasAppliedImpulse =`
217	`437`	`!IsRadialProjectionEqualToFixed(`
217	`438`	`primaryAtCommon,`
217	`439`	`desiredPrimarySign,`
217	`440`	`dynamicNumerator,`
217	`441`	`dynamicDenominator,`
217	`442`	`magnitudeSquared,`
217	`443`	`accumulatedPrimaryTangentImpulse)`
217	`444`	`\|\| !IsRadialProjectionEqualToFixed(`
217	`445`	`secondaryAtCommon,`
217	`446`	`desiredSecondarySign,`
217	`447`	`dynamicNumerator,`
217	`448`	`dynamicDenominator,`
217	`449`	`magnitudeSquared,`
217	`450`	`accumulatedSecondaryTangentImpulse);`
217	`451`	`resolved = TryGetDiskVelocityDeltas(`
217	`452`	`primaryFirst,`
217	`453`	`primarySecond,`
217	`454`	`secondaryFirst,`
217	`455`	`secondarySecond,`
217	`456`	`primaryTangent,`
217	`457`	`secondaryTangent,`
217	`458`	`primaryAtCommon,`
217	`459`	`desiredPrimarySign,`
217	`460`	`secondaryAtCommon,`
217	`461`	`desiredSecondarySign,`
217	`462`	`commonDenominator,`
217	`463`	`rational: false,`
217	`464`	`dynamicNumerator,`
217	`465`	`dynamicDenominator,`
217	`466`	`magnitudeSquared,`
217	`467`	`accumulatedPrimaryTangentImpulse,`
217	`468`	`accumulatedSecondaryTangentImpulse,`
217	`469`	`out firstLinear,`
217	`470`	`out firstAngular,`
217	`471`	`out secondLinear,`
217	`472`	`out secondAngular);`
	`473`	`}`
	`474`	`else`
	`475`	`{`
222	`476`	`Span<ulong> zero = stackalloc ulong[MaxCoulombWords];`
222	`477`	`Span<ulong> appliedPrimaryNumerator =`
222	`478`	`stackalloc ulong[MaxCoulombWords];`
222	`479`	`Span<ulong> appliedDenominator =`
222	`480`	`stackalloc ulong[MaxCoulombWords];`
222	`481`	`Span<ulong> appliedSecondaryNumerator =`
222	`482`	`stackalloc ulong[MaxCoulombWords];`
222	`483`	`zero.Clear();`
222	`484`	`SubtractFixedFromRatio(`
222	`485`	`withinStaticLimit ? primaryAtCommon : zero,`
222	`486`	`commonDenominator,`
222	`487`	`withinStaticLimit ? desiredPrimarySign : 0,`
222	`488`	`accumulatedPrimaryTangentImpulse,`
222	`489`	`appliedPrimaryNumerator,`
222	`490`	`appliedDenominator,`
222	`491`	`out int appliedPrimarySign);`
222	`492`	`SubtractFixedFromRatio(`
222	`493`	`withinStaticLimit ? secondaryAtCommon : zero,`
222	`494`	`commonDenominator,`
222	`495`	`withinStaticLimit ? desiredSecondarySign : 0,`
222	`496`	`accumulatedSecondaryTangentImpulse,`
222	`497`	`appliedSecondaryNumerator,`
222	`498`	`appliedDenominator,`
222	`499`	`out int appliedSecondarySign);`
222	`500`	`hasAppliedImpulse =`
222	`501`	`appliedPrimarySign != 0`
222	`502`	`\|\| appliedSecondarySign != 0;`
222	`503`	`resolved = TryGetDiskVelocityDeltas(`
222	`504`	`primaryFirst,`
222	`505`	`primarySecond,`
222	`506`	`secondaryFirst,`
222	`507`	`secondarySecond,`
222	`508`	`primaryTangent,`
222	`509`	`secondaryTangent,`
222	`510`	`appliedPrimaryNumerator,`
222	`511`	`appliedPrimarySign,`
222	`512`	`appliedSecondaryNumerator,`
222	`513`	`appliedSecondarySign,`
222	`514`	`appliedDenominator,`
222	`515`	`rational: true,`
222	`516`	`dynamicNumerator,`
222	`517`	`dynamicDenominator,`
222	`518`	`magnitudeSquared,`
222	`519`	`Fixed64.Zero,`
222	`520`	`Fixed64.Zero,`
222	`521`	`out firstLinear,`
222	`522`	`out firstAngular,`
222	`523`	`out secondLinear,`
222	`524`	`out secondAngular);`
	`525`	`}`
439	`526`	`if (!resolved)`
6	`527`	`return false;`
	`528`
	`529`	`bool hasPrimaryProjection;`
	`530`	`bool hasSecondaryProjection;`
	`531`	`Fixed64 primaryProjection;`
	`532`	`Fixed64 secondaryProjection;`
433	`533`	`if (withinStaticLimit)`
	`534`	`{`
213	`535`	`hasPrimaryProjection = Fixed64.TryGetSignedRawRatio(`
213	`536`	`primaryAtCommon,`
213	`537`	`commonDenominator,`
213	`538`	`desiredPrimarySign < 0,`
213	`539`	`out primaryProjection);`
213	`540`	`hasSecondaryProjection = Fixed64.TryGetSignedRawRatio(`
213	`541`	`secondaryAtCommon,`
213	`542`	`commonDenominator,`
213	`543`	`desiredSecondarySign < 0,`
213	`544`	`out secondaryProjection);`
	`545`	`}`
220	`546`	`else if (useDynamicProjection)`
	`547`	`{`
214	`548`	`Span<ulong> projectedNumerator =`
214	`549`	`stackalloc ulong[MaxCoulombWords + MaxResponseWords];`
214	`550`	`WideArithmetic.MultiplyMagnitudes(`
214	`551`	`primaryAtCommon,`
214	`552`	`dynamicNumerator,`
214	`553`	`projectedNumerator);`
214	`554`	`hasPrimaryProjection = TryGetSignedRatioOverSquareRoot(`
214	`555`	`projectedNumerator,`
214	`556`	`dynamicDenominator,`
214	`557`	`magnitudeSquared,`
214	`558`	`desiredPrimarySign < 0,`
214	`559`	`out primaryProjection);`
214	`560`	`WideArithmetic.MultiplyMagnitudes(`
214	`561`	`secondaryAtCommon,`
214	`562`	`dynamicNumerator,`
214	`563`	`projectedNumerator);`
214	`564`	`hasSecondaryProjection = TryGetSignedRatioOverSquareRoot(`
214	`565`	`projectedNumerator,`
214	`566`	`dynamicDenominator,`
214	`567`	`magnitudeSquared,`
214	`568`	`desiredSecondarySign < 0,`
214	`569`	`out secondaryProjection);`
	`570`	`}`
	`571`	`else`
	`572`	`{`
6	`573`	`hasPrimaryProjection = true;`
6	`574`	`hasSecondaryProjection = true;`
6	`575`	`primaryProjection = Fixed64.Zero;`
6	`576`	`secondaryProjection = Fixed64.Zero;`
	`577`	`}`
	`578`
433	`579`	`response = new ExactCoulombResponse3D(`
433	`580`	`hasAppliedImpulse,`
433	`581`	`firstLinear,`
433	`582`	`firstAngular,`
433	`583`	`secondLinear,`
433	`584`	`secondAngular,`
433	`585`	`hasPrimaryProjection,`
433	`586`	`primaryProjection,`
433	`587`	`hasSecondaryProjection,`
433	`588`	`secondaryProjection);`
433	`589`	`return true;`
	`590`	`}`
	`591`
	`592`	`private static bool AreCoulombDiskInputsValid(`
	`593`	`Vector3d normal,`
	`594`	`in ExactContactResponseOperand3D primaryFirst,`
	`595`	`in ExactContactResponseOperand3D primarySecond,`
	`596`	`Vector3d primaryTangent,`
	`597`	`in ExactContactResponseOperand3D secondaryFirst,`
	`598`	`in ExactContactResponseOperand3D secondarySecond,`
	`599`	`Vector3d secondaryTangent,`
	`600`	`Fixed64 staticFriction,`
	`601`	`Fixed64 dynamicFriction) =>`
444	`602`	`staticFriction >= Fixed64.Zero`
444	`603`	`& dynamicFriction >= Fixed64.Zero`
444	`604`	`& primaryFirst.Lever.Denominator.Sign != 0`
444	`605`	`& primarySecond.Lever.Denominator.Sign != 0`
444	`606`	`& primaryFirst.InverseMass >= Fixed64.Zero`
444	`607`	`& primarySecond.InverseMass >= Fixed64.Zero`
444	`608`	`& normal.IsNormalized()`
444	`609`	`& primaryTangent.IsNormalized()`
444	`610`	`& secondaryTangent.IsNormalized()`
444	`611`	`& FixedMath.Abs(Vector3d.Dot(`
444	`612`	`primaryTangent,`
444	`613`	`secondaryTangent)) <= Fixed64.Epsilon`
444	`614`	`& FixedMath.Abs(Vector3d.Dot(`
444	`615`	`normal,`
444	`616`	`primaryTangent)) <= Fixed64.Epsilon`
444	`617`	`& FixedMath.Abs(Vector3d.Dot(`
444	`618`	`normal,`
444	`619`	`secondaryTangent)) <= Fixed64.Epsilon`
444	`620`	`& HaveMatchingParticipants(primaryFirst, secondaryFirst)`
444	`621`	`& HaveMatchingParticipants(primarySecond, secondarySecond);`
	`622`
	`623`	`private static bool TryGetCompletedNormalAccumulatorRatio(`
	`624`	`in ExactNormalConstraint3D constraint,`
	`625`	`Span<ulong> numerator,`
	`626`	`Span<ulong> denominator)`
	`627`	`{`
110	`628`	`numerator.Clear();`
110	`629`	`denominator.Clear();`
110	`630`	`ExactContactResponseOperand3D first = constraint.First;`
110	`631`	`ExactContactResponseOperand3D second = constraint.Second;`
110	`632`	`bool inputsValid =`
110	`633`	`first.Lever.Denominator.Sign != 0`
110	`634`	`& second.Lever.Denominator.Sign != 0`
110	`635`	`& constraint.Restitution >= Fixed64.Zero`
110	`636`	`& constraint.RestitutionVelocityThreshold >= Fixed64.Zero`
110	`637`	`& constraint.AccumulatedImpulse >= Fixed64.Zero`
110	`638`	`& constraint.PositiveImpulseScale >= Fixed64.Zero`
110	`639`	`& constraint.NegativeImpulseScale >= Fixed64.Zero`
110	`640`	`& first.InverseMass >= Fixed64.Zero`
110	`641`	`& second.InverseMass >= Fixed64.Zero`
110	`642`	`& constraint.Normal.IsNormalized();`
110	`643`	`if (!inputsValid)`
2	`644`	`return false;`
	`645`
108	`646`	`ExactLever3D.GetRelativePointVelocityRatio(`
108	`647`	`first.LinearVelocity,`
108	`648`	`first.AngularVelocity,`
108	`649`	`first.Lever,`
108	`650`	`second.LinearVelocity,`
108	`651`	`second.AngularVelocity,`
108	`652`	`second.Lever,`
108	`653`	`constraint.Normal,`
108	`654`	`out Signed832 velocityNumerator,`
108	`655`	`out Signed832 velocityDenominator);`
	`656`
108	`657`	`Span<ulong> effectiveNumerator = stackalloc ulong[MaxResponseWords];`
108	`658`	`Span<ulong> effectiveDenominator = stackalloc ulong[MaxResponseWords];`
108	`659`	`GetEffectiveMassRatio(`
108	`660`	`first,`
108	`661`	`second,`
108	`662`	`constraint.Normal,`
108	`663`	`effectiveNumerator,`
108	`664`	`effectiveDenominator);`
108	`665`	`int velocitySign =`
108	`666`	`velocityNumerator.Sign * velocityDenominator.Sign;`
108	`667`	`if (velocitySign == 0`
108	`668`	`\|\| WideArithmetic.IsZeroMagnitude(effectiveNumerator))`
	`669`	`{`
12	`670`	`SetMagnitude(constraint.AccumulatedImpulse, numerator);`
12	`671`	`denominator[0] = 1UL;`
12	`672`	`return true;`
	`673`	`}`
	`674`
96	`675`	`bool hasVelocityProjection = Fixed64.TryGetSignedRawRatio(`
96	`676`	`velocityNumerator,`
96	`677`	`velocityDenominator,`
96	`678`	`0,`
96	`679`	`out Fixed64 velocityProjection);`
96	`680`	`bool applyRestitution = velocitySign < 0`
96	`681`	`& (!hasVelocityProjection`
96	`682`	`\| velocityProjection`
96	`683`	`< -constraint.RestitutionVelocityThreshold);`
96	`684`	`Fixed64 scale = velocitySign < 0`
96	`685`	`? constraint.PositiveImpulseScale`
96	`686`	`: constraint.NegativeImpulseScale;`
96	`687`	`Span<ulong> impulseNumerator = stackalloc ulong[MaxResponseWords];`
96	`688`	`Span<ulong> impulseDenominator = stackalloc ulong[MaxResponseWords];`
96	`689`	`BuildImpulseRatio(`
96	`690`	`velocityNumerator,`
96	`691`	`velocityDenominator,`
96	`692`	`effectiveNumerator,`
96	`693`	`effectiveDenominator,`
96	`694`	`applyRestitution ? constraint.Restitution : Fixed64.Zero,`
96	`695`	`scale,`
96	`696`	`impulseNumerator,`
96	`697`	`impulseDenominator);`
	`698`
96	`699`	`Span<ulong> accumulatorMagnitude =`
96	`700`	`stackalloc ulong[MaxResponseWords];`
96	`701`	`Span<ulong> accumulatorAtImpulseDenominator =`
96	`702`	`stackalloc ulong[MaxResponseWords];`
96	`703`	`SetMagnitude(constraint.AccumulatedImpulse, accumulatorMagnitude);`
96	`704`	`WideArithmetic.MultiplyMagnitudes(`
96	`705`	`accumulatorMagnitude,`
96	`706`	`impulseDenominator,`
96	`707`	`accumulatorAtImpulseDenominator);`
96	`708`	`int impulseSign = -velocitySign;`
96	`709`	`if (impulseSign < 0`
96	`710`	`&& WideArithmetic.CompareMagnitudeEqualLength(`
96	`711`	`impulseNumerator,`
96	`712`	`accumulatorAtImpulseDenominator) >= 0)`
	`713`	`{`
1	`714`	`denominator[0] = 1UL;`
1	`715`	`return true;`
	`716`	`}`
	`717`
95	`718`	`accumulatorAtImpulseDenominator.CopyTo(numerator);`
95	`719`	`if (impulseSign > 0)`
93	`720`	`WideArithmetic.AddMagnitudeInto(impulseNumerator, numerator);`
	`721`	`else`
2	`722`	`WideArithmetic.SubtractEqualMagnitudes(`
2	`723`	`accumulatorAtImpulseDenominator,`
2	`724`	`impulseNumerator,`
2	`725`	`numerator);`
95	`726`	`impulseDenominator.CopyTo(denominator);`
95	`727`	`return true;`
	`728`	`}`
	`729`
	`730`	`private static void GetBilateralImpulseRatio(`
	`731`	`in ExactContactResponseOperand3D first,`
	`732`	`in ExactContactResponseOperand3D second,`
	`733`	`Vector3d tangent,`
	`734`	`Fixed64 velocityDeadzone,`
	`735`	`Span<ulong> numerator,`
	`736`	`Span<ulong> denominator,`
	`737`	`out int sign)`
	`738`	`{`
931	`739`	`numerator.Clear();`
931	`740`	`denominator.Clear();`
931	`741`	`sign = 0;`
931	`742`	`ExactLever3D.GetRelativePointVelocityRatio(`
931	`743`	`first.LinearVelocity,`
931	`744`	`first.AngularVelocity,`
931	`745`	`first.Lever,`
931	`746`	`second.LinearVelocity,`
931	`747`	`second.AngularVelocity,`
931	`748`	`second.Lever,`
931	`749`	`tangent,`
931	`750`	`out Signed832 velocityNumerator,`
931	`751`	`out Signed832 velocityDenominator);`
	`752`
931	`753`	`Span<ulong> effectiveNumerator = stackalloc ulong[MaxResponseWords];`
931	`754`	`Span<ulong> effectiveDenominator = stackalloc ulong[MaxResponseWords];`
931	`755`	`GetEffectiveMassRatio(`
931	`756`	`first,`
931	`757`	`second,`
931	`758`	`tangent,`
931	`759`	`effectiveNumerator,`
931	`760`	`effectiveDenominator);`
931	`761`	`int velocitySign =`
931	`762`	`velocityNumerator.Sign * velocityDenominator.Sign;`
931	`763`	`bool suppressVelocity = velocityDeadzone != Fixed64.Zero`
931	`764`	`&& Fixed64.TryGetSignedRawRatio(`
931	`765`	`velocityNumerator,`
931	`766`	`velocityDenominator,`
931	`767`	`0,`
931	`768`	`out Fixed64 velocityProjection)`
931	`769`	`&& velocityProjection >= -velocityDeadzone`
931	`770`	`&& velocityProjection <= velocityDeadzone;`
931	`771`	`if (velocitySign == 0`
931	`772`	`\|\| suppressVelocity`
931	`773`	`\|\| WideArithmetic.IsZeroMagnitude(effectiveNumerator))`
	`774`	`{`
467	`775`	`denominator[0] = 1UL;`
467	`776`	`return;`
	`777`	`}`
	`778`
464	`779`	`BuildImpulseRatio(`
464	`780`	`velocityNumerator,`
464	`781`	`velocityDenominator,`
464	`782`	`effectiveNumerator,`
464	`783`	`effectiveDenominator,`
464	`784`	`Fixed64.Zero,`
464	`785`	`Fixed64.One,`
464	`786`	`numerator,`
464	`787`	`denominator);`
464	`788`	`sign = -velocitySign;`
464	`789`	`}`
	`790`
	`791`	`private static void GetFrictionLimit(`
	`792`	`ReadOnlySpan<ulong> normalNumerator,`
	`793`	`ReadOnlySpan<ulong> normalDenominator,`
	`794`	`Fixed64 friction,`
	`795`	`Span<ulong> numerator,`
	`796`	`Span<ulong> denominator)`
	`797`	`{`
733	`798`	`Span<ulong> frictionMagnitude =`
733	`799`	`stackalloc ulong[3];`
733	`800`	`Span<ulong> fixedScale =`
733	`801`	`stackalloc ulong[1];`
733	`802`	`SetMagnitude(friction, frictionMagnitude);`
733	`803`	`fixedScale.Clear();`
733	`804`	`fixedScale[0] = (ulong)FixedMath.ONE_L;`
733	`805`	`WideArithmetic.MultiplyMagnitudes(`
733	`806`	`normalNumerator,`
733	`807`	`frictionMagnitude,`
733	`808`	`numerator);`
733	`809`	`WideArithmetic.MultiplyMagnitudes(`
733	`810`	`normalDenominator,`
733	`811`	`fixedScale,`
733	`812`	`denominator);`
733	`813`	`}`
	`814`
	`815`	`private static void AddFixedToRatio(`
	`816`	`ReadOnlySpan<ulong> ratioNumerator,`
	`817`	`ReadOnlySpan<ulong> ratioDenominator,`
	`818`	`int ratioSign,`
	`819`	`Fixed64 value,`
	`820`	`Span<ulong> resultNumerator,`
	`821`	`out int resultSign)`
	`822`	`{`
931	`823`	`Span<ulong> valueMagnitude = stackalloc ulong[3];`
931	`824`	`Span<ulong> valueAtDenominator =`
931	`825`	`stackalloc ulong[MaxResponseWords];`
931	`826`	`SetMagnitude(value, valueMagnitude);`
931	`827`	`WideArithmetic.MultiplyMagnitudes(`
931	`828`	`valueMagnitude,`
931	`829`	`ratioDenominator,`
931	`830`	`valueAtDenominator);`
931	`831`	`AddSignedMagnitudes(`
931	`832`	`ratioNumerator,`
931	`833`	`ratioSign,`
931	`834`	`valueAtDenominator,`
931	`835`	`value == Fixed64.Zero ? 0 : value < Fixed64.Zero ? -1 : 1,`
931	`836`	`resultNumerator,`
931	`837`	`out resultSign);`
931	`838`	`}`
	`839`
	`840`	`private static void SubtractFixedFromRatio(`
	`841`	`ReadOnlySpan<ulong> ratioNumerator,`
	`842`	`ReadOnlySpan<ulong> ratioDenominator,`
	`843`	`int ratioSign,`
	`844`	`Fixed64 value,`
	`845`	`Span<ulong> resultNumerator,`
	`846`	`Span<ulong> resultDenominator,`
	`847`	`out int resultSign)`
	`848`	`{`
460	`849`	`Span<ulong> valueMagnitude = stackalloc ulong[3];`
460	`850`	`Span<ulong> valueAtDenominator =`
460	`851`	`stackalloc ulong[MaxCoulombWords];`
460	`852`	`SetMagnitude(value, valueMagnitude);`
460	`853`	`WideArithmetic.MultiplyMagnitudes(`
460	`854`	`valueMagnitude,`
460	`855`	`ratioDenominator,`
460	`856`	`valueAtDenominator);`
460	`857`	`AddSignedMagnitudes(`
460	`858`	`ratioNumerator,`
460	`859`	`ratioSign,`
460	`860`	`valueAtDenominator,`
460	`861`	`value == Fixed64.Zero ? 0 : value < Fixed64.Zero ? 1 : -1,`
460	`862`	`resultNumerator,`
460	`863`	`out resultSign);`
460	`864`	`resultDenominator.Clear();`
460	`865`	`ratioDenominator.CopyTo(resultDenominator);`
460	`866`	`}`
	`867`
	`868`	`private static int CompareRatios(`
	`869`	`ReadOnlySpan<ulong> firstNumerator,`
	`870`	`ReadOnlySpan<ulong> firstDenominator,`
	`871`	`ReadOnlySpan<ulong> secondNumerator,`
	`872`	`ReadOnlySpan<ulong> secondDenominator)`
	`873`	`{`
53	`874`	`Span<ulong> first = stackalloc ulong[MaxCoulombWords];`
53	`875`	`Span<ulong> second = stackalloc ulong[MaxCoulombWords];`
53	`876`	`WideArithmetic.MultiplyMagnitudes(`
53	`877`	`firstNumerator,`
53	`878`	`secondDenominator,`
53	`879`	`first);`
53	`880`	`WideArithmetic.MultiplyMagnitudes(`
53	`881`	`secondNumerator,`
53	`882`	`firstDenominator,`
53	`883`	`second);`
53	`884`	`return WideArithmetic.CompareMagnitudeEqualLength(first, second);`
	`885`	`}`
	`886`
	`887`	`private static bool IsVectorWithinLimit(`
	`888`	`ReadOnlySpan<ulong> vectorMagnitudeSquared,`
	`889`	`ReadOnlySpan<ulong> vectorDenominator,`
	`890`	`ReadOnlySpan<ulong> limitNumerator,`
	`891`	`ReadOnlySpan<ulong> limitDenominator)`
	`892`	`{`
439	`893`	`Span<ulong> denominatorSquared =`
439	`894`	`stackalloc ulong[MaxCoulombSquareWords];`
439	`895`	`Span<ulong> limitNumeratorSquared =`
439	`896`	`stackalloc ulong[MaxCoulombSquareWords];`
439	`897`	`Span<ulong> limitDenominatorSquared =`
439	`898`	`stackalloc ulong[MaxCoulombSquareWords];`
439	`899`	`Span<ulong> left = stackalloc ulong[MaxCoulombComparisonWords];`
439	`900`	`Span<ulong> right = stackalloc ulong[MaxCoulombComparisonWords];`
439	`901`	`WideArithmetic.MultiplyMagnitudes(`
439	`902`	`vectorDenominator,`
439	`903`	`vectorDenominator,`
439	`904`	`denominatorSquared);`
439	`905`	`WideArithmetic.MultiplyMagnitudes(`
439	`906`	`limitNumerator,`
439	`907`	`limitNumerator,`
439	`908`	`limitNumeratorSquared);`
439	`909`	`WideArithmetic.MultiplyMagnitudes(`
439	`910`	`limitDenominator,`
439	`911`	`limitDenominator,`
439	`912`	`limitDenominatorSquared);`
439	`913`	`WideArithmetic.MultiplyMagnitudes(`
439	`914`	`vectorMagnitudeSquared,`
439	`915`	`limitDenominatorSquared,`
439	`916`	`left);`
439	`917`	`WideArithmetic.MultiplyMagnitudes(`
439	`918`	`limitNumeratorSquared,`
439	`919`	`denominatorSquared,`
439	`920`	`right);`
439	`921`	`return WideArithmetic.CompareMagnitudeEqualLength(left, right) <= 0;`
	`922`	`}`
	`923`
	`924`	`private static void AddSignedMagnitudes(`
	`925`	`ReadOnlySpan<ulong> first,`
	`926`	`int firstSign,`
	`927`	`ReadOnlySpan<ulong> second,`
	`928`	`int secondSign,`
	`929`	`Span<ulong> result,`
	`930`	`out int resultSign)`
	`931`	`{`
64205	`932`	`result.Clear();`
64205	`933`	`resultSign = 0;`
64205	`934`	`if (firstSign != 0 & !WideArithmetic.IsZeroMagnitude(first))`
50021	`935`	`WideArithmetic.AddSignedMagnitude(`
50021	`936`	`first,`
50021	`937`	`firstSign,`
50021	`938`	`result,`
50021	`939`	`ref resultSign);`
64205	`940`	`if (secondSign != 0 & !WideArithmetic.IsZeroMagnitude(second))`
54775	`941`	`WideArithmetic.AddSignedMagnitude(`
54775	`942`	`second,`
54775	`943`	`secondSign,`
54775	`944`	`result,`
54775	`945`	`ref resultSign);`
64205	`946`	`}`
	`947`
	`948`	`private static bool TryGetSignedRatioOverSquareRoot(`
	`949`	`ReadOnlySpan<ulong> numerator,`
	`950`	`ReadOnlySpan<ulong> denominator,`
	`951`	`ReadOnlySpan<ulong> radicand,`
	`952`	`bool negative,`
	`953`	`out Fixed64 result)`
	`954`	`{`
428	`955`	`if (WideArithmetic.IsZeroMagnitude(numerator))`
	`956`	`{`
206	`957`	`result = Fixed64.Zero;`
206	`958`	`return true;`
	`959`	`}`
	`960`
222	`961`	`ulong limit = negative ? 1UL << 63 : (ulong)long.MaxValue;`
222	`962`	`if (CompareRatioOverSquareRoot(`
222	`963`	`numerator,`
222	`964`	`denominator,`
222	`965`	`radicand,`
222	`966`	`limit) > 0)`
	`967`	`{`
2	`968`	`result = default;`
2	`969`	`return false;`
	`970`	`}`
	`971`
220	`972`	`ulong low = 0UL;`
220	`973`	`ulong high = limit;`
14083	`974`	`while (low < high)`
	`975`	`{`
13863	`976`	`ulong difference = high - low;`
13863	`977`	`ulong middle = low + (difference >> 1) + (difference & 1UL);`
13863	`978`	`if (CompareRatioOverSquareRoot(`
13863	`979`	`numerator,`
13863	`980`	`denominator,`
13863	`981`	`radicand,`
13863	`982`	`middle) >= 0)`
	`983`	`{`
3394	`984`	`low = middle;`
	`985`	`}`
	`986`	`else`
	`987`	`{`
10469	`988`	`high = middle - 1UL;`
	`989`	`}`
	`990`	`}`
	`991`
220	`992`	`ulong quotient = low;`
220	`993`	`Span<ulong> doubledQuotient = stackalloc ulong[2];`
220	`994`	`doubledQuotient[0] = (quotient << 1) \| 1UL;`
220	`995`	`doubledQuotient[1] = quotient >> 63;`
220	`996`	`int midpointComparison = CompareRatioOverSquareRoot(`
220	`997`	`numerator,`
220	`998`	`denominator,`
220	`999`	`radicand,`
220	`1000`	`doubledQuotient,`
220	`1001`	`numeratorMultiplier: 2UL);`
220	`1002`	`bool roundUp = midpointComparison > 0`
220	`1003`	`\| (midpointComparison == 0 & (quotient & 1UL) != 0UL);`
220	`1004`	`if (roundUp & quotient < limit)`
	`1005`	`{`
10	`1006`	`quotient++;`
	`1007`	`}`
	`1008`
220	`1009`	`result = new Fixed64(`
220	`1010`	`negative ? unchecked(-(long)quotient) : (long)quotient);`
220	`1011`	`return true;`
	`1012`	`}`
	`1013`
	`1014`	`private static int CompareRatioOverSquareRoot(`
	`1015`	`ReadOnlySpan<ulong> numerator,`
	`1016`	`ReadOnlySpan<ulong> denominator,`
	`1017`	`ReadOnlySpan<ulong> radicand,`
	`1018`	`ulong candidate)`
	`1019`	`{`
14085	`1020`	`Span<ulong> candidateMagnitude = stackalloc ulong[1];`
14085	`1021`	`candidateMagnitude.Clear();`
14085	`1022`	`candidateMagnitude[0] = candidate;`
14085	`1023`	`return CompareRatioOverSquareRoot(`
14085	`1024`	`numerator,`
14085	`1025`	`denominator,`
14085	`1026`	`radicand,`
14085	`1027`	`candidateMagnitude,`
14085	`1028`	`numeratorMultiplier: 1UL);`
	`1029`	`}`
	`1030`
	`1031`	`private static int CompareRatioOverSquareRoot(`
	`1032`	`ReadOnlySpan<ulong> numerator,`
	`1033`	`ReadOnlySpan<ulong> denominator,`
	`1034`	`ReadOnlySpan<ulong> radicand,`
	`1035`	`ReadOnlySpan<ulong> candidate,`
	`1036`	`ulong numeratorMultiplier)`
	`1037`	`{`
14305	`1038`	`Span<ulong> multiplier = stackalloc ulong[1];`
14305	`1039`	`multiplier.Clear();`
14305	`1040`	`multiplier[0] = numeratorMultiplier;`
14305	`1041`	`Span<ulong> scaledNumerator =`
14305	`1042`	`stackalloc ulong[(MaxCoulombComparisonWords / 2) + 1];`
14305	`1043`	`Span<ulong> left = stackalloc ulong[MaxCoulombComparisonWords];`
14305	`1044`	`Span<ulong> denominatorTimesCandidate =`
14305	`1045`	`stackalloc ulong[(MaxCoulombComparisonWords / 2) + 1];`
14305	`1046`	`Span<ulong> rightBase =`
14305	`1047`	`stackalloc ulong[MaxCoulombComparisonWords];`
14305	`1048`	`Span<ulong> right = stackalloc ulong[MaxCoulombComparisonWords];`
14305	`1049`	`WideArithmetic.MultiplyMagnitudes(`
14305	`1050`	`numerator,`
14305	`1051`	`multiplier,`
14305	`1052`	`scaledNumerator);`
14305	`1053`	`WideArithmetic.MultiplyMagnitudes(`
14305	`1054`	`scaledNumerator,`
14305	`1055`	`scaledNumerator,`
14305	`1056`	`left);`
14305	`1057`	`WideArithmetic.MultiplyMagnitudes(`
14305	`1058`	`denominator,`
14305	`1059`	`candidate,`
14305	`1060`	`denominatorTimesCandidate);`
14305	`1061`	`WideArithmetic.MultiplyMagnitudes(`
14305	`1062`	`denominatorTimesCandidate,`
14305	`1063`	`denominatorTimesCandidate,`
14305	`1064`	`rightBase);`
14305	`1065`	`WideArithmetic.MultiplyMagnitudes(rightBase, radicand, right);`
14305	`1066`	`return WideArithmetic.CompareMagnitudeEqualLength(left, right);`
	`1067`	`}`
	`1068`
	`1069`	`private static bool HaveMatchingParticipants(`
	`1070`	`in ExactContactResponseOperand3D first,`
	`1071`	`in ExactContactResponseOperand3D second) =>`
1236	`1072`	`first.Lever.XNumerator.Equals(second.Lever.XNumerator)`
1236	`1073`	`& first.Lever.YNumerator.Equals(second.Lever.YNumerator)`
1236	`1074`	`& first.Lever.ZNumerator.Equals(second.Lever.ZNumerator)`
1236	`1075`	`& first.Lever.Denominator.Equals(second.Lever.Denominator)`
1236	`1076`	`& first.InverseMass == second.InverseMass`
1236	`1077`	`& first.InverseInertia == second.InverseInertia;`
	`1078`	`}`

/home/runner/work/Gravitas/Gravitas/src/Gravitas/CollisionHandling/Response/Exact/ExactContactResponseKernel.CoulombDiskCache.cs

#	Line	Line coverage
	`1`	`//=======================================================================`
	`2`	`// ExactContactResponseKernel.CoulombDiskCache.cs`
	`3`	`//=======================================================================`
	`4`	`// MIT License, Copyright (c) 2026-present David Oravsky (mrdav30)`
	`5`	`// See LICENSE file in the project root for full license information.`
	`6`	`//=======================================================================`
	`7`
	`8`	`using System;`
	`9`
	`10`	`using FixedMathSharp;`
	`11`
	`12`	`namespace Gravitas.CollisionHandling;`
	`13`
	`14`	`/// <content>`
	`15`	`/// Owns exact cached-disk projection comparison and materialization.`
	`16`	`/// </content>`
	`17`	`internal static partial class ExactContactResponseKernel`
	`18`	`{`
	`19`	`private static bool IsRadialProjectionEqualToFixed(`
	`20`	`ReadOnlySpan<ulong> directionNumerator,`
	`21`	`int directionSign,`
	`22`	`ReadOnlySpan<ulong> radialNumerator,`
	`23`	`ReadOnlySpan<ulong> radialDenominator,`
	`24`	`ReadOnlySpan<ulong> radicand,`
	`25`	`Fixed64 value)`
	`26`	`{`
411	`27`	`Span<ulong> projectedNumerator =`
411	`28`	`stackalloc ulong[MaxCoulombComparisonWords / 2];`
411	`29`	`Span<ulong> valueMagnitude = stackalloc ulong[3];`
411	`30`	`Span<ulong> fixedDenominator = stackalloc ulong[1];`
411	`31`	`WideArithmetic.MultiplyMagnitudes(`
411	`32`	`directionNumerator,`
411	`33`	`radialNumerator,`
411	`34`	`projectedNumerator);`
411	`35`	`SetMagnitude(value, valueMagnitude);`
411	`36`	`fixedDenominator.Clear();`
411	`37`	`fixedDenominator[0] = 1UL;`
411	`38`	`int valueSign =`
411	`39`	`value == Fixed64.Zero ? 0 : value < Fixed64.Zero ? -1 : 1;`
411	`40`	`return CompareSignedRadicalAndRationalSumToMagnitude(`
411	`41`	`projectedNumerator,`
411	`42`	`radialDenominator,`
411	`43`	`radicand,`
411	`44`	`directionSign,`
411	`45`	`valueMagnitude,`
411	`46`	`fixedDenominator,`
411	`47`	`-valueSign,`
411	`48`	`candidate: 0UL)`
411	`49`	`== 0;`
	`50`	`}`
	`51`
	`52`	`internal static bool TryGetSignedRadicalAndRationalSum(`
	`53`	`ReadOnlySpan<ulong> radicalNumerator,`
	`54`	`ReadOnlySpan<ulong> radicalDenominator,`
	`55`	`ReadOnlySpan<ulong> radicand,`
	`56`	`int radicalSign,`
	`57`	`ReadOnlySpan<ulong> rationalNumerator,`
	`58`	`ReadOnlySpan<ulong> rationalDenominator,`
	`59`	`int rationalSign,`
	`60`	`out Fixed64 result)`
	`61`	`{`
2566	`62`	`int resultSign = CompareSignedRadicalAndRationalSumToMagnitude(`
2566	`63`	`radicalNumerator,`
2566	`64`	`radicalDenominator,`
2566	`65`	`radicand,`
2566	`66`	`radicalSign,`
2566	`67`	`rationalNumerator,`
2566	`68`	`rationalDenominator,`
2566	`69`	`rationalSign,`
2566	`70`	`candidate: 0UL);`
2566	`71`	`if (resultSign == 0)`
	`72`	`{`
1760	`73`	`result = Fixed64.Zero;`
1760	`74`	`return true;`
	`75`	`}`
	`76`
806	`77`	`int normalizedRadicalSign =`
806	`78`	`resultSign < 0 ? -radicalSign : radicalSign;`
806	`79`	`int normalizedRationalSign =`
806	`80`	`resultSign < 0 ? -rationalSign : rationalSign;`
806	`81`	`ulong limit =`
806	`82`	`resultSign < 0 ? 1UL << 63 : (ulong)long.MaxValue;`
806	`83`	`Span<ulong> doubledLimit = stackalloc ulong[2];`
806	`84`	`doubledLimit[0] = (limit << 1) \| 1UL;`
806	`85`	`doubledLimit[1] = limit >> 63;`
806	`86`	`int limitMidpointComparison =`
806	`87`	`CompareSignedRadicalAndRationalSumToMagnitude(`
806	`88`	`radicalNumerator,`
806	`89`	`radicalDenominator,`
806	`90`	`radicand,`
806	`91`	`normalizedRadicalSign,`
806	`92`	`rationalNumerator,`
806	`93`	`rationalDenominator,`
806	`94`	`normalizedRationalSign,`
806	`95`	`doubledLimit,`
806	`96`	`expressionMultiplier: 2UL);`
806	`97`	`if (limitMidpointComparison > 0`
806	`98`	`\|\| (limitMidpointComparison == 0`
806	`99`	`&& (limit & 1UL) != 0UL))`
	`100`	`{`
6	`101`	`result = default;`
6	`102`	`return false;`
	`103`	`}`
	`104`
800	`105`	`ulong low = 0UL;`
800	`106`	`ulong high = limit;`
51201	`107`	`while (low < high)`
	`108`	`{`
50401	`109`	`ulong difference = high - low;`
50401	`110`	`ulong middle =`
50401	`111`	`low + (difference >> 1) + (difference & 1UL);`
50401	`112`	`if (CompareSignedRadicalAndRationalSumToMagnitude(`
50401	`113`	`radicalNumerator,`
50401	`114`	`radicalDenominator,`
50401	`115`	`radicand,`
50401	`116`	`normalizedRadicalSign,`
50401	`117`	`rationalNumerator,`
50401	`118`	`rationalDenominator,`
50401	`119`	`normalizedRationalSign,`
50401	`120`	`middle) >= 0)`
	`121`	`{`
11761	`122`	`low = middle;`
	`123`	`}`
	`124`	`else`
	`125`	`{`
38640	`126`	`high = middle - 1UL;`
	`127`	`}`
	`128`	`}`
	`129`
800	`130`	`ulong quotient = low;`
800	`131`	`Span<ulong> doubledQuotient = stackalloc ulong[2];`
800	`132`	`doubledQuotient[0] = (quotient << 1) \| 1UL;`
800	`133`	`doubledQuotient[1] = quotient >> 63;`
800	`134`	`int midpointComparison =`
800	`135`	`CompareSignedRadicalAndRationalSumToMagnitude(`
800	`136`	`radicalNumerator,`
800	`137`	`radicalDenominator,`
800	`138`	`radicand,`
800	`139`	`normalizedRadicalSign,`
800	`140`	`rationalNumerator,`
800	`141`	`rationalDenominator,`
800	`142`	`normalizedRationalSign,`
800	`143`	`doubledQuotient,`
800	`144`	`expressionMultiplier: 2UL);`
800	`145`	`bool roundUp = midpointComparison > 0`
800	`146`	`\| (midpointComparison == 0 & (quotient & 1UL) != 0UL);`
800	`147`	`if (roundUp & quotient < limit)`
244	`148`	`quotient++;`
	`149`
800	`150`	`result = new Fixed64(`
800	`151`	`resultSign < 0`
800	`152`	`? unchecked(-(long)quotient)`
800	`153`	`: (long)quotient);`
800	`154`	`return true;`
	`155`	`}`
	`156`
	`157`	`private static int CompareSignedRadicalAndRationalSumToMagnitude(`
	`158`	`ReadOnlySpan<ulong> radicalNumerator,`
	`159`	`ReadOnlySpan<ulong> radicalDenominator,`
	`160`	`ReadOnlySpan<ulong> radicand,`
	`161`	`int radicalSign,`
	`162`	`ReadOnlySpan<ulong> rationalNumerator,`
	`163`	`ReadOnlySpan<ulong> rationalDenominator,`
	`164`	`int rationalSign,`
	`165`	`ulong candidate)`
	`166`	`{`
53378	`167`	`Span<ulong> candidateMagnitude = stackalloc ulong[1];`
53378	`168`	`candidateMagnitude[0] = candidate;`
53378	`169`	`return CompareSignedRadicalAndRationalSumToMagnitude(`
53378	`170`	`radicalNumerator,`
53378	`171`	`radicalDenominator,`
53378	`172`	`radicand,`
53378	`173`	`radicalSign,`
53378	`174`	`rationalNumerator,`
53378	`175`	`rationalDenominator,`
53378	`176`	`rationalSign,`
53378	`177`	`candidateMagnitude,`
53378	`178`	`expressionMultiplier: 1UL);`
	`179`	`}`
	`180`
	`181`	`private static int CompareSignedRadicalAndRationalSumToMagnitude(`
	`182`	`ReadOnlySpan<ulong> radicalNumerator,`
	`183`	`ReadOnlySpan<ulong> radicalDenominator,`
	`184`	`ReadOnlySpan<ulong> radicand,`
	`185`	`int radicalSign,`
	`186`	`ReadOnlySpan<ulong> rationalNumerator,`
	`187`	`ReadOnlySpan<ulong> rationalDenominator,`
	`188`	`int rationalSign,`
	`189`	`ReadOnlySpan<ulong> candidate,`
	`190`	`ulong expressionMultiplier)`
	`191`	`{`
54984	`192`	`Span<ulong> multiplier = stackalloc ulong[1];`
54984	`193`	`Span<ulong> scaledRadicalNumerator =`
54984	`194`	`stackalloc ulong[MaxCoulombComparisonWords];`
54984	`195`	`Span<ulong> scaledRationalNumerator =`
54984	`196`	`stackalloc ulong[MaxCoulombComparisonWords];`
54984	`197`	`Span<ulong> candidateAtDenominator =`
54984	`198`	`stackalloc ulong[MaxCoulombComparisonWords];`
54984	`199`	`Span<ulong> adjustedRationalNumerator =`
54984	`200`	`stackalloc ulong[MaxCoulombComparisonWords];`
54984	`201`	`Span<ulong> rationalTerm =`
54984	`202`	`stackalloc ulong[MaxCoulombComparisonWords];`
54984	`203`	`Span<ulong> radicalCoefficient =`
54984	`204`	`stackalloc ulong[MaxCoulombComparisonWords];`
54984	`205`	`multiplier[0] = expressionMultiplier;`
54984	`206`	`WideArithmetic.MultiplyMagnitudes(`
54984	`207`	`radicalNumerator,`
54984	`208`	`multiplier,`
54984	`209`	`scaledRadicalNumerator);`
54984	`210`	`WideArithmetic.MultiplyMagnitudes(`
54984	`211`	`rationalNumerator,`
54984	`212`	`multiplier,`
54984	`213`	`scaledRationalNumerator);`
54984	`214`	`WideArithmetic.MultiplyMagnitudes(`
54984	`215`	`candidate,`
54984	`216`	`rationalDenominator,`
54984	`217`	`candidateAtDenominator);`
54984	`218`	`AddSignedMagnitudes(`
54984	`219`	`scaledRationalNumerator,`
54984	`220`	`rationalSign,`
54984	`221`	`candidateAtDenominator,`
54984	`222`	`-1,`
54984	`223`	`adjustedRationalNumerator,`
54984	`224`	`out int adjustedRationalSign);`
54984	`225`	`WideArithmetic.MultiplyMagnitudes(`
54984	`226`	`scaledRadicalNumerator,`
54984	`227`	`rationalDenominator,`
54984	`228`	`rationalTerm);`
54984	`229`	`WideArithmetic.MultiplyMagnitudes(`
54984	`230`	`adjustedRationalNumerator,`
54984	`231`	`radicalDenominator,`
54984	`232`	`radicalCoefficient);`
54984	`233`	`return WideArithmetic.GetSignedMagnitudeAndSquareRootSign(`
54984	`234`	`TrimMagnitude(rationalTerm),`
54984	`235`	`radicalSign,`
54984	`236`	`TrimMagnitude(radicalCoefficient),`
54984	`237`	`adjustedRationalSign,`
54984	`238`	`TrimMagnitude(radicand));`
	`239`	`}`
	`240`
	`241`	`private static void GetWeightedFixedSum(`
	`242`	`Fixed64 firstFactor,`
	`243`	`Fixed64 firstValue,`
	`244`	`Fixed64 secondFactor,`
	`245`	`Fixed64 secondValue,`
	`246`	`Span<ulong> result,`
	`247`	`out int resultSign)`
	`248`	`{`
1260	`249`	`Span<ulong> factorMagnitude = stackalloc ulong[3];`
1260	`250`	`Span<ulong> valueMagnitude = stackalloc ulong[3];`
1260	`251`	`Span<ulong> first = stackalloc ulong[3];`
1260	`252`	`Span<ulong> second = stackalloc ulong[3];`
1260	`253`	`SetMagnitude(firstFactor, factorMagnitude);`
1260	`254`	`SetMagnitude(firstValue, valueMagnitude);`
1260	`255`	`WideArithmetic.MultiplyMagnitudes(`
1260	`256`	`factorMagnitude,`
1260	`257`	`valueMagnitude,`
1260	`258`	`first);`
1260	`259`	`SetMagnitude(secondFactor, factorMagnitude);`
1260	`260`	`SetMagnitude(secondValue, valueMagnitude);`
1260	`261`	`WideArithmetic.MultiplyMagnitudes(`
1260	`262`	`factorMagnitude,`
1260	`263`	`valueMagnitude,`
1260	`264`	`second);`
1260	`265`	`AddSignedMagnitudes(`
1260	`266`	`first,`
1260	`267`	`GetProductSign(firstFactor, firstValue),`
1260	`268`	`second,`
1260	`269`	`GetProductSign(secondFactor, secondValue),`
1260	`270`	`result,`
1260	`271`	`out resultSign);`
1260	`272`	`}`
	`273`
	`274`	`private static void GetWeightedSignedWideSum(`
	`275`	`Signed832 firstFactor,`
	`276`	`Fixed64 firstValue,`
	`277`	`Signed832 secondFactor,`
	`278`	`Fixed64 secondValue,`
	`279`	`Span<ulong> result,`
	`280`	`out int resultSign)`
	`281`	`{`
1302	`282`	`Span<ulong> factorMagnitude = stackalloc ulong[13];`
1302	`283`	`Span<ulong> valueMagnitude = stackalloc ulong[3];`
1302	`284`	`Span<ulong> first = stackalloc ulong[15];`
1302	`285`	`Span<ulong> second = stackalloc ulong[15];`
1302	`286`	`SetMagnitude(firstFactor, factorMagnitude);`
1302	`287`	`SetMagnitude(firstValue, valueMagnitude);`
1302	`288`	`WideArithmetic.MultiplyMagnitudes(`
1302	`289`	`factorMagnitude,`
1302	`290`	`valueMagnitude,`
1302	`291`	`first);`
1302	`292`	`SetMagnitude(secondFactor, factorMagnitude);`
1302	`293`	`SetMagnitude(secondValue, valueMagnitude);`
1302	`294`	`WideArithmetic.MultiplyMagnitudes(`
1302	`295`	`factorMagnitude,`
1302	`296`	`valueMagnitude,`
1302	`297`	`second);`
1302	`298`	`AddSignedMagnitudes(`
1302	`299`	`first,`
1302	`300`	`firstFactor.Sign * Math.Sign(firstValue.m_rawValue),`
1302	`301`	`second,`
1302	`302`	`secondFactor.Sign * Math.Sign(secondValue.m_rawValue),`
1302	`303`	`result,`
1302	`304`	`out resultSign);`
1302	`305`	`}`
	`306`
	`307`	`private static int GetProductSign(Fixed64 first, Fixed64 second) =>`
2520	`308`	`Math.Sign(first.m_rawValue) * Math.Sign(second.m_rawValue);`
	`309`
	`310`	`private static ReadOnlySpan<ulong> TrimMagnitude(`
	`311`	`ReadOnlySpan<ulong> value)`
	`312`	`{`
164952	`313`	`int length = value.Length;`
40996574	`314`	`while (length > 0 && value[length - 1] == 0UL)`
40831622	`315`	`length--;`
164952	`316`	`return value.Slice(0, length);`
	`317`	`}`
	`318`
	`319`	`private static bool TryGetDiskVelocityDeltas(`
	`320`	`in ExactContactResponseOperand3D primaryFirst,`
	`321`	`in ExactContactResponseOperand3D primarySecond,`
	`322`	`in ExactContactResponseOperand3D secondaryFirst,`
	`323`	`in ExactContactResponseOperand3D secondarySecond,`
	`324`	`Vector3d primaryTangent,`
	`325`	`Vector3d secondaryTangent,`
	`326`	`ReadOnlySpan<ulong> primaryNumerator,`
	`327`	`int primarySign,`
	`328`	`ReadOnlySpan<ulong> secondaryNumerator,`
	`329`	`int secondarySign,`
	`330`	`ReadOnlySpan<ulong> commonDenominator,`
	`331`	`bool rational,`
	`332`	`ReadOnlySpan<ulong> radialNumerator,`
	`333`	`ReadOnlySpan<ulong> radialDenominator,`
	`334`	`ReadOnlySpan<ulong> radicand,`
	`335`	`Fixed64 accumulatedPrimaryTangentImpulse,`
	`336`	`Fixed64 accumulatedSecondaryTangentImpulse,`
	`337`	`out Vector3d firstLinear,`
	`338`	`out Vector3d firstAngular,`
	`339`	`out Vector3d secondLinear,`
	`340`	`out Vector3d secondAngular)`
	`341`	`{`
439	`342`	`bool resolved = TryGetDiskLinearVelocityDelta(`
439	`343`	`primaryFirst.LinearImpulseAxis,`
439	`344`	`secondaryFirst.LinearImpulseAxis,`
439	`345`	`primaryFirst.InverseMass,`
439	`346`	`primaryNumerator,`
439	`347`	`primarySign,`
439	`348`	`secondaryNumerator,`
439	`349`	`secondarySign,`
439	`350`	`commonDenominator,`
439	`351`	`rational,`
439	`352`	`radialNumerator,`
439	`353`	`radialDenominator,`
439	`354`	`radicand,`
439	`355`	`accumulatedPrimaryTangentImpulse,`
439	`356`	`accumulatedSecondaryTangentImpulse,`
439	`357`	`out firstLinear);`
439	`358`	`resolved &= TryGetDiskAngularVelocityDelta(`
439	`359`	`primaryFirst.Lever,`
439	`360`	`-primaryTangent,`
439	`361`	`-secondaryTangent,`
439	`362`	`primaryFirst.InverseInertia,`
439	`363`	`primaryNumerator,`
439	`364`	`primarySign,`
439	`365`	`secondaryNumerator,`
439	`366`	`secondarySign,`
439	`367`	`commonDenominator,`
439	`368`	`rational,`
439	`369`	`radialNumerator,`
439	`370`	`radialDenominator,`
439	`371`	`radicand,`
439	`372`	`accumulatedPrimaryTangentImpulse,`
439	`373`	`accumulatedSecondaryTangentImpulse,`
439	`374`	`out firstAngular);`
439	`375`	`resolved &= TryGetDiskLinearVelocityDelta(`
439	`376`	`primarySecond.LinearImpulseAxis,`
439	`377`	`secondarySecond.LinearImpulseAxis,`
439	`378`	`primarySecond.InverseMass,`
439	`379`	`primaryNumerator,`
439	`380`	`primarySign,`
439	`381`	`secondaryNumerator,`
439	`382`	`secondarySign,`
439	`383`	`commonDenominator,`
439	`384`	`rational,`
439	`385`	`radialNumerator,`
439	`386`	`radialDenominator,`
439	`387`	`radicand,`
439	`388`	`accumulatedPrimaryTangentImpulse,`
439	`389`	`accumulatedSecondaryTangentImpulse,`
439	`390`	`out secondLinear);`
439	`391`	`resolved &= TryGetDiskAngularVelocityDelta(`
439	`392`	`primarySecond.Lever,`
439	`393`	`primaryTangent,`
439	`394`	`secondaryTangent,`
439	`395`	`primarySecond.InverseInertia,`
439	`396`	`primaryNumerator,`
439	`397`	`primarySign,`
439	`398`	`secondaryNumerator,`
439	`399`	`secondarySign,`
439	`400`	`commonDenominator,`
439	`401`	`rational,`
439	`402`	`radialNumerator,`
439	`403`	`radialDenominator,`
439	`404`	`radicand,`
439	`405`	`accumulatedPrimaryTangentImpulse,`
439	`406`	`accumulatedSecondaryTangentImpulse,`
439	`407`	`out secondAngular);`
439	`408`	`return resolved;`
	`409`	`}`
	`410`
	`411`	`private static bool TryGetDiskLinearVelocityDelta(`
	`412`	`Vector3d primaryAxis,`
	`413`	`Vector3d secondaryAxis,`
	`414`	`Fixed64 inverseMass,`
	`415`	`ReadOnlySpan<ulong> primaryNumerator,`
	`416`	`int primarySign,`
	`417`	`ReadOnlySpan<ulong> secondaryNumerator,`
	`418`	`int secondarySign,`
	`419`	`ReadOnlySpan<ulong> commonDenominator,`
	`420`	`bool rational,`
	`421`	`ReadOnlySpan<ulong> radialNumerator,`
	`422`	`ReadOnlySpan<ulong> radialDenominator,`
	`423`	`ReadOnlySpan<ulong> radicand,`
	`424`	`Fixed64 accumulatedPrimaryTangentImpulse,`
	`425`	`Fixed64 accumulatedSecondaryTangentImpulse,`
	`426`	`out Vector3d result)`
	`427`	`{`
878	`428`	`bool xResolved = TryGetDiskLinearComponent(`
878	`429`	`primaryAxis.X,`
878	`430`	`secondaryAxis.X,`
878	`431`	`inverseMass,`
878	`432`	`primaryNumerator,`
878	`433`	`primarySign,`
878	`434`	`secondaryNumerator,`
878	`435`	`secondarySign,`
878	`436`	`commonDenominator,`
878	`437`	`rational,`
878	`438`	`radialNumerator,`
878	`439`	`radialDenominator,`
878	`440`	`radicand,`
878	`441`	`accumulatedPrimaryTangentImpulse,`
878	`442`	`accumulatedSecondaryTangentImpulse,`
878	`443`	`out Fixed64 x);`
878	`444`	`bool yResolved = TryGetDiskLinearComponent(`
878	`445`	`primaryAxis.Y,`
878	`446`	`secondaryAxis.Y,`
878	`447`	`inverseMass,`
878	`448`	`primaryNumerator,`
878	`449`	`primarySign,`
878	`450`	`secondaryNumerator,`
878	`451`	`secondarySign,`
878	`452`	`commonDenominator,`
878	`453`	`rational,`
878	`454`	`radialNumerator,`
878	`455`	`radialDenominator,`
878	`456`	`radicand,`
878	`457`	`accumulatedPrimaryTangentImpulse,`
878	`458`	`accumulatedSecondaryTangentImpulse,`
878	`459`	`out Fixed64 y);`
878	`460`	`bool zResolved = TryGetDiskLinearComponent(`
878	`461`	`primaryAxis.Z,`
878	`462`	`secondaryAxis.Z,`
878	`463`	`inverseMass,`
878	`464`	`primaryNumerator,`
878	`465`	`primarySign,`
878	`466`	`secondaryNumerator,`
878	`467`	`secondarySign,`
878	`468`	`commonDenominator,`
878	`469`	`rational,`
878	`470`	`radialNumerator,`
878	`471`	`radialDenominator,`
878	`472`	`radicand,`
878	`473`	`accumulatedPrimaryTangentImpulse,`
878	`474`	`accumulatedSecondaryTangentImpulse,`
878	`475`	`out Fixed64 z);`
878	`476`	`result = xResolved & yResolved & zResolved`
878	`477`	`? new Vector3d(x, y, z)`
878	`478`	`: default;`
878	`479`	`return xResolved & yResolved & zResolved;`
	`480`	`}`
	`481`
	`482`	`private static bool TryGetDiskLinearComponent(`
	`483`	`Fixed64 primaryAxis,`
	`484`	`Fixed64 secondaryAxis,`
	`485`	`Fixed64 inverseMass,`
	`486`	`ReadOnlySpan<ulong> primaryNumerator,`
	`487`	`int primarySign,`
	`488`	`ReadOnlySpan<ulong> secondaryNumerator,`
	`489`	`int secondarySign,`
	`490`	`ReadOnlySpan<ulong> commonDenominator,`
	`491`	`bool rational,`
	`492`	`ReadOnlySpan<ulong> radialNumerator,`
	`493`	`ReadOnlySpan<ulong> radialDenominator,`
	`494`	`ReadOnlySpan<ulong> radicand,`
	`495`	`Fixed64 accumulatedPrimaryTangentImpulse,`
	`496`	`Fixed64 accumulatedSecondaryTangentImpulse,`
	`497`	`out Fixed64 result)`
	`498`	`{`
2634	`499`	`Span<ulong> combined = stackalloc ulong[MaxCoulombWords + 2];`
2634	`500`	`GetWeightedSignedSum(`
2634	`501`	`primaryAxis,`
2634	`502`	`primaryNumerator,`
2634	`503`	`primarySign,`
2634	`504`	`secondaryAxis,`
2634	`505`	`secondaryNumerator,`
2634	`506`	`secondarySign,`
2634	`507`	`combined,`
2634	`508`	`out int combinedSign);`
2634	`509`	`if (inverseMass == Fixed64.Zero)`
	`510`	`{`
93	`511`	`result = Fixed64.Zero;`
93	`512`	`return true;`
	`513`	`}`
	`514`
2541	`515`	`Span<ulong> inverseMassMagnitude =`
2541	`516`	`stackalloc ulong[3];`
2541	`517`	`Span<ulong> fixedScale = stackalloc ulong[1];`
2541	`518`	`Span<ulong> numerator = stackalloc ulong[MaxCoulombComparisonWords / 2];`
2541	`519`	`Span<ulong> denominator =`
2541	`520`	`stackalloc ulong[MaxCoulombComparisonWords / 2];`
2541	`521`	`SetMagnitude(inverseMass, inverseMassMagnitude);`
2541	`522`	`fixedScale.Clear();`
2541	`523`	`fixedScale[0] = (ulong)FixedMath.ONE_L;`
2541	`524`	`Multiply3(`
2541	`525`	`commonDenominator,`
2541	`526`	`fixedScale,`
2541	`527`	`fixedScale,`
2541	`528`	`denominator);`
2541	`529`	`if (rational)`
	`530`	`{`
1281	`531`	`if (combinedSign == 0)`
	`532`	`{`
877	`533`	`result = Fixed64.Zero;`
877	`534`	`return true;`
	`535`	`}`
	`536`
404	`537`	`WideArithmetic.MultiplyMagnitudes(`
404	`538`	`combined,`
404	`539`	`inverseMassMagnitude,`
404	`540`	`numerator);`
404	`541`	`return Fixed64.TryGetSignedRawRatio(`
404	`542`	`numerator,`
404	`543`	`denominator,`
404	`544`	`combinedSign < 0,`
404	`545`	`out result);`
	`546`	`}`
	`547`
1260	`548`	`Span<ulong> scaledNumerator =`
1260	`549`	`stackalloc ulong[MaxCoulombComparisonWords / 2];`
1260	`550`	`Span<ulong> radicalDenominator =`
1260	`551`	`stackalloc ulong[MaxCoulombComparisonWords / 2];`
1260	`552`	`Span<ulong> cachedCombined = stackalloc ulong[3];`
1260	`553`	`Span<ulong> cachedNumerator = stackalloc ulong[4];`
1260	`554`	`Span<ulong> cachedDenominator = stackalloc ulong[2];`
1260	`555`	`WideArithmetic.MultiplyMagnitudes(`
1260	`556`	`combined,`
1260	`557`	`inverseMassMagnitude,`
1260	`558`	`numerator);`
1260	`559`	`WideArithmetic.MultiplyMagnitudes(`
1260	`560`	`numerator,`
1260	`561`	`radialNumerator,`
1260	`562`	`scaledNumerator);`
1260	`563`	`WideArithmetic.MultiplyMagnitudes(`
1260	`564`	`radialDenominator,`
1260	`565`	`fixedScale,`
1260	`566`	`radicalDenominator);`
1260	`567`	`WideArithmetic.MultiplyMagnitudes(`
1260	`568`	`radicalDenominator,`
1260	`569`	`fixedScale,`
1260	`570`	`denominator);`
1260	`571`	`GetWeightedFixedSum(`
1260	`572`	`primaryAxis,`
1260	`573`	`accumulatedPrimaryTangentImpulse,`
1260	`574`	`secondaryAxis,`
1260	`575`	`accumulatedSecondaryTangentImpulse,`
1260	`576`	`cachedCombined,`
1260	`577`	`out int cachedSign);`
1260	`578`	`WideArithmetic.MultiplyMagnitudes(`
1260	`579`	`cachedCombined,`
1260	`580`	`inverseMassMagnitude,`
1260	`581`	`cachedNumerator);`
1260	`582`	`WideArithmetic.MultiplyMagnitudes(`
1260	`583`	`fixedScale,`
1260	`584`	`fixedScale,`
1260	`585`	`cachedDenominator);`
1260	`586`	`return TryGetSignedRadicalAndRationalSum(`
1260	`587`	`scaledNumerator,`
1260	`588`	`denominator,`
1260	`589`	`radicand,`
1260	`590`	`combinedSign,`
1260	`591`	`cachedNumerator,`
1260	`592`	`cachedDenominator,`
1260	`593`	`-cachedSign,`
1260	`594`	`out result);`
	`595`	`}`
	`596`
	`597`	`private static bool TryGetDiskAngularVelocityDelta(`
	`598`	`in ExactLever3D lever,`
	`599`	`Vector3d primaryAxis,`
	`600`	`Vector3d secondaryAxis,`
	`601`	`Fixed3x3 inverseInertia,`
	`602`	`ReadOnlySpan<ulong> primaryNumerator,`
	`603`	`int primarySign,`
	`604`	`ReadOnlySpan<ulong> secondaryNumerator,`
	`605`	`int secondarySign,`
	`606`	`ReadOnlySpan<ulong> commonDenominator,`
	`607`	`bool rational,`
	`608`	`ReadOnlySpan<ulong> radialNumerator,`
	`609`	`ReadOnlySpan<ulong> radialDenominator,`
	`610`	`ReadOnlySpan<ulong> radicand,`
	`611`	`Fixed64 accumulatedPrimaryTangentImpulse,`
	`612`	`Fixed64 accumulatedSecondaryTangentImpulse,`
	`613`	`out Vector3d result)`
	`614`	`{`
878	`615`	`ExactLever3D.GetTransformedCrossProduct(`
878	`616`	`lever,`
878	`617`	`primaryAxis,`
878	`618`	`inverseInertia,`
878	`619`	`out Signed832 primaryX,`
878	`620`	`out Signed832 primaryY,`
878	`621`	`out Signed832 primaryZ);`
878	`622`	`ExactLever3D.GetTransformedCrossProduct(`
878	`623`	`lever,`
878	`624`	`secondaryAxis,`
878	`625`	`inverseInertia,`
878	`626`	`out Signed832 secondaryX,`
878	`627`	`out Signed832 secondaryY,`
878	`628`	`out Signed832 secondaryZ);`
878	`629`	`Signed320 fixedScaleSquared = WideArithmetic.MultiplySigned192(`
878	`630`	`Signed192.One,`
878	`631`	`Signed192.One);`
878	`632`	`Signed704 transformedDenominator =`
878	`633`	`WideArithmetic.MultiplySigned576ToSigned704(`
878	`634`	`lever.Denominator,`
878	`635`	`fixedScaleSquared);`
	`636`
878	`637`	`bool xResolved = TryGetDiskAngularComponent(`
878	`638`	`primaryX,`
878	`639`	`secondaryX,`
878	`640`	`transformedDenominator,`
878	`641`	`primaryNumerator,`
878	`642`	`primarySign,`
878	`643`	`secondaryNumerator,`
878	`644`	`secondarySign,`
878	`645`	`commonDenominator,`
878	`646`	`rational,`
878	`647`	`radialNumerator,`
878	`648`	`radialDenominator,`
878	`649`	`radicand,`
878	`650`	`accumulatedPrimaryTangentImpulse,`
878	`651`	`accumulatedSecondaryTangentImpulse,`
878	`652`	`out Fixed64 x);`
878	`653`	`bool yResolved = TryGetDiskAngularComponent(`
878	`654`	`primaryY,`
878	`655`	`secondaryY,`
878	`656`	`transformedDenominator,`
878	`657`	`primaryNumerator,`
878	`658`	`primarySign,`
878	`659`	`secondaryNumerator,`
878	`660`	`secondarySign,`
878	`661`	`commonDenominator,`
878	`662`	`rational,`
878	`663`	`radialNumerator,`
878	`664`	`radialDenominator,`
878	`665`	`radicand,`
878	`666`	`accumulatedPrimaryTangentImpulse,`
878	`667`	`accumulatedSecondaryTangentImpulse,`
878	`668`	`out Fixed64 y);`
878	`669`	`bool zResolved = TryGetDiskAngularComponent(`
878	`670`	`primaryZ,`
878	`671`	`secondaryZ,`
878	`672`	`transformedDenominator,`
878	`673`	`primaryNumerator,`
878	`674`	`primarySign,`
878	`675`	`secondaryNumerator,`
878	`676`	`secondarySign,`
878	`677`	`commonDenominator,`
878	`678`	`rational,`
878	`679`	`radialNumerator,`
878	`680`	`radialDenominator,`
878	`681`	`radicand,`
878	`682`	`accumulatedPrimaryTangentImpulse,`
878	`683`	`accumulatedSecondaryTangentImpulse,`
878	`684`	`out Fixed64 z);`
878	`685`	`result = xResolved & yResolved & zResolved`
878	`686`	`? new Vector3d(x, y, z)`
878	`687`	`: default;`
878	`688`	`return xResolved & yResolved & zResolved;`
	`689`	`}`
	`690`
	`691`	`private static bool TryGetDiskAngularComponent(`
	`692`	`Signed832 primary,`
	`693`	`Signed832 secondary,`
	`694`	`Signed704 transformedDenominator,`
	`695`	`ReadOnlySpan<ulong> primaryNumerator,`
	`696`	`int primarySign,`
	`697`	`ReadOnlySpan<ulong> secondaryNumerator,`
	`698`	`int secondarySign,`
	`699`	`ReadOnlySpan<ulong> commonDenominator,`
	`700`	`bool rational,`
	`701`	`ReadOnlySpan<ulong> radialNumerator,`
	`702`	`ReadOnlySpan<ulong> radialDenominator,`
	`703`	`ReadOnlySpan<ulong> radicand,`
	`704`	`Fixed64 accumulatedPrimaryTangentImpulse,`
	`705`	`Fixed64 accumulatedSecondaryTangentImpulse,`
	`706`	`out Fixed64 result)`
	`707`	`{`
2634	`708`	`Span<ulong> primaryMagnitude = stackalloc ulong[13];`
2634	`709`	`Span<ulong> secondaryMagnitude = stackalloc ulong[13];`
2634	`710`	`SetMagnitude(primary, primaryMagnitude);`
2634	`711`	`SetMagnitude(secondary, secondaryMagnitude);`
2634	`712`	`Span<ulong> primaryProduct =`
2634	`713`	`stackalloc ulong[MaxCoulombComparisonWords / 2];`
2634	`714`	`Span<ulong> secondaryProduct =`
2634	`715`	`stackalloc ulong[MaxCoulombComparisonWords / 2];`
2634	`716`	`WideArithmetic.MultiplyMagnitudes(`
2634	`717`	`primaryMagnitude,`
2634	`718`	`primaryNumerator,`
2634	`719`	`primaryProduct);`
2634	`720`	`WideArithmetic.MultiplyMagnitudes(`
2634	`721`	`secondaryMagnitude,`
2634	`722`	`secondaryNumerator,`
2634	`723`	`secondaryProduct);`
2634	`724`	`Span<ulong> combined =`
2634	`725`	`stackalloc ulong[MaxCoulombComparisonWords / 2];`
2634	`726`	`AddSignedMagnitudes(`
2634	`727`	`primaryProduct,`
2634	`728`	`primary.Sign * primarySign,`
2634	`729`	`secondaryProduct,`
2634	`730`	`secondary.Sign * secondarySign,`
2634	`731`	`combined,`
2634	`732`	`out int combinedSign);`
	`733`
2634	`734`	`Span<ulong> transformedDenominatorMagnitude =`
2634	`735`	`stackalloc ulong[11];`
2634	`736`	`Span<ulong> fixedScale = stackalloc ulong[1];`
2634	`737`	`Span<ulong> denominator =`
2634	`738`	`stackalloc ulong[MaxCoulombComparisonWords / 2];`
2634	`739`	`SetMagnitude(transformedDenominator, transformedDenominatorMagnitude);`
2634	`740`	`fixedScale.Clear();`
2634	`741`	`fixedScale[0] = (ulong)FixedMath.ONE_L;`
2634	`742`	`Multiply3(`
2634	`743`	`transformedDenominatorMagnitude,`
2634	`744`	`commonDenominator,`
2634	`745`	`fixedScale,`
2634	`746`	`denominator);`
2634	`747`	`if (rational)`
	`748`	`{`
1332	`749`	`if (combinedSign == 0)`
	`750`	`{`
994	`751`	`result = Fixed64.Zero;`
994	`752`	`return true;`
	`753`	`}`
	`754`
338	`755`	`return Fixed64.TryGetSignedRawRatio(`
338	`756`	`combined,`
338	`757`	`denominator,`
338	`758`	`combinedSign < 0,`
338	`759`	`out result);`
	`760`	`}`
	`761`
1302	`762`	`Span<ulong> scaledNumerator =`
1302	`763`	`stackalloc ulong[MaxCoulombComparisonWords / 2];`
1302	`764`	`Span<ulong> radicalDenominator =`
1302	`765`	`stackalloc ulong[MaxCoulombComparisonWords / 2];`
1302	`766`	`Span<ulong> cachedCombined = stackalloc ulong[15];`
1302	`767`	`Span<ulong> cachedDenominator = stackalloc ulong[12];`
1302	`768`	`WideArithmetic.MultiplyMagnitudes(`
1302	`769`	`combined,`
1302	`770`	`radialNumerator,`
1302	`771`	`scaledNumerator);`
1302	`772`	`WideArithmetic.MultiplyMagnitudes(`
1302	`773`	`transformedDenominatorMagnitude,`
1302	`774`	`radialDenominator,`
1302	`775`	`radicalDenominator);`
1302	`776`	`WideArithmetic.MultiplyMagnitudes(`
1302	`777`	`radicalDenominator,`
1302	`778`	`fixedScale,`
1302	`779`	`denominator);`
1302	`780`	`GetWeightedSignedWideSum(`
1302	`781`	`primary,`
1302	`782`	`accumulatedPrimaryTangentImpulse,`
1302	`783`	`secondary,`
1302	`784`	`accumulatedSecondaryTangentImpulse,`
1302	`785`	`cachedCombined,`
1302	`786`	`out int cachedSign);`
1302	`787`	`WideArithmetic.MultiplyMagnitudes(`
1302	`788`	`transformedDenominatorMagnitude,`
1302	`789`	`fixedScale,`
1302	`790`	`cachedDenominator);`
1302	`791`	`return TryGetSignedRadicalAndRationalSum(`
1302	`792`	`scaledNumerator,`
1302	`793`	`denominator,`
1302	`794`	`radicand,`
1302	`795`	`combinedSign,`
1302	`796`	`cachedCombined,`
1302	`797`	`cachedDenominator,`
1302	`798`	`-cachedSign,`
1302	`799`	`out result);`
	`800`	`}`
	`801`
	`802`	`private static void GetWeightedSignedSum(`
	`803`	`Fixed64 firstFactor,`
	`804`	`ReadOnlySpan<ulong> firstMagnitude,`
	`805`	`int firstSign,`
	`806`	`Fixed64 secondFactor,`
	`807`	`ReadOnlySpan<ulong> secondMagnitude,`
	`808`	`int secondSign,`
	`809`	`Span<ulong> result,`
	`810`	`out int resultSign)`
	`811`	`{`
2634	`812`	`Span<ulong> factorMagnitude = stackalloc ulong[3];`
2634	`813`	`Span<ulong> first = stackalloc ulong[MaxCoulombWords + 2];`
2634	`814`	`Span<ulong> second = stackalloc ulong[MaxCoulombWords + 2];`
2634	`815`	`SetMagnitude(firstFactor, factorMagnitude);`
2634	`816`	`WideArithmetic.MultiplyMagnitudes(`
2634	`817`	`factorMagnitude,`
2634	`818`	`firstMagnitude,`
2634	`819`	`first);`
2634	`820`	`SetMagnitude(secondFactor, factorMagnitude);`
2634	`821`	`WideArithmetic.MultiplyMagnitudes(`
2634	`822`	`factorMagnitude,`
2634	`823`	`secondMagnitude,`
2634	`824`	`second);`
2634	`825`	`AddSignedMagnitudes(`
2634	`826`	`first,`
2634	`827`	`firstFactor == Fixed64.Zero`
2634	`828`	`? 0`
2634	`829`	`: firstFactor < Fixed64.Zero ? -firstSign : firstSign,`
2634	`830`	`second,`
2634	`831`	`secondFactor == Fixed64.Zero`
2634	`832`	`? 0`
2634	`833`	`: secondFactor < Fixed64.Zero ? -secondSign : secondSign,`
2634	`834`	`result,`
2634	`835`	`out resultSign);`
2634	`836`	`}`
	`837`
	`838`	`}`

/home/runner/work/Gravitas/Gravitas/src/Gravitas/CollisionHandling/Response/Exact/ExactContactResponseKernel.Normal.cs

#	Line	Line coverage
	`1`	`//=======================================================================`
	`2`	`// ExactContactResponseKernel.Normal.cs`
	`3`	`//=======================================================================`
	`4`	`// MIT License, Copyright (c) 2026-present David Oravsky (mrdav30)`
	`5`	`// See LICENSE file in the project root for full license information.`
	`6`	`//=======================================================================`
	`7`
	`8`	`using System;`
	`9`	`using System.Runtime.CompilerServices;`
	`10`
	`11`	`using FixedMathSharp;`
	`12`	`using FixedMathSharp.Geometry;`
	`13`
	`14`	`namespace Gravitas.CollisionHandling;`
	`15`
	`16`	`/// <content>`
	`17`	`/// Owns unilateral exact normal-response policy and materialization.`
	`18`	`/// </content>`
	`19`	`internal static partial class ExactContactResponseKernel`
	`20`	`{`
	`21`	`[MethodImpl(MethodImplOptions.AggressiveInlining)]`
	`22`	`internal static bool TryGetNormalResponse(`
	`23`	`in ExactContactResponseOperand3D first,`
	`24`	`in ExactContactResponseOperand3D second,`
	`25`	`Vector3d normal,`
	`26`	`Fixed64 restitution,`
	`27`	`Fixed64 restitutionVelocityThreshold,`
	`28`	`out ExactNormalResponse3D response) =>`
210	`29`	`TryGetNormalResponseCore(`
210	`30`	`first,`
210	`31`	`second,`
210	`32`	`normal,`
210	`33`	`restitution,`
210	`34`	`restitutionVelocityThreshold,`
210	`35`	`accumulatedImpulse: Fixed64.Zero,`
210	`36`	`positiveImpulseScale: Fixed64.One,`
210	`37`	`negativeImpulseScale: Fixed64.One,`
210	`38`	`includeAccumulator: false,`
210	`39`	`out response);`
	`40`
	`41`	`[MethodImpl(MethodImplOptions.AggressiveInlining)]`
	`42`	`internal static bool TryGetAccumulatedNormalResponse(`
	`43`	`in ExactContactResponseOperand3D first,`
	`44`	`in ExactContactResponseOperand3D second,`
	`45`	`Vector3d normal,`
	`46`	`Fixed64 restitution,`
	`47`	`Fixed64 restitutionVelocityThreshold,`
	`48`	`Fixed64 accumulatedImpulse,`
	`49`	`Fixed64 positiveImpulseScale,`
	`50`	`Fixed64 negativeImpulseScale,`
	`51`	`out ExactNormalResponse3D response) =>`
1471	`52`	`TryGetNormalResponseCore(`
1471	`53`	`first,`
1471	`54`	`second,`
1471	`55`	`normal,`
1471	`56`	`restitution,`
1471	`57`	`restitutionVelocityThreshold,`
1471	`58`	`accumulatedImpulse,`
1471	`59`	`positiveImpulseScale,`
1471	`60`	`negativeImpulseScale,`
1471	`61`	`includeAccumulator: true,`
1471	`62`	`out response);`
	`63`
	`64`	`[MethodImpl(MethodImplOptions.NoInlining)]`
	`65`	`private static bool TryGetNormalResponseCore(`
	`66`	`in ExactContactResponseOperand3D first,`
	`67`	`in ExactContactResponseOperand3D second,`
	`68`	`Vector3d normal,`
	`69`	`Fixed64 restitution,`
	`70`	`Fixed64 restitutionVelocityThreshold,`
	`71`	`Fixed64 accumulatedImpulse,`
	`72`	`Fixed64 positiveImpulseScale,`
	`73`	`Fixed64 negativeImpulseScale,`
	`74`	`bool includeAccumulator,`
	`75`	`out ExactNormalResponse3D response)`
	`76`	`{`
1681	`77`	`response = default;`
1681	`78`	`if (first.Lever.Denominator.Sign == 0`
1681	`79`	`\|\| second.Lever.Denominator.Sign == 0`
1681	`80`	`\|\| restitution < Fixed64.Zero`
1681	`81`	`\|\| restitutionVelocityThreshold < Fixed64.Zero`
1681	`82`	`\|\| accumulatedImpulse < Fixed64.Zero`
1681	`83`	`\|\| positiveImpulseScale < Fixed64.Zero`
1681	`84`	`\|\| negativeImpulseScale < Fixed64.Zero`
1681	`85`	`\|\| first.InverseMass < Fixed64.Zero`
1681	`86`	`\|\| second.InverseMass < Fixed64.Zero`
1681	`87`	`\|\| !normal.IsNormalized())`
	`88`	`{`
13	`89`	`return false;`
	`90`	`}`
	`91`
1668	`92`	`ExactLever3D.GetRelativePointVelocityRatio(`
1668	`93`	`first.LinearVelocity,`
1668	`94`	`first.AngularVelocity,`
1668	`95`	`first.Lever,`
1668	`96`	`second.LinearVelocity,`
1668	`97`	`second.AngularVelocity,`
1668	`98`	`second.Lever,`
1668	`99`	`normal,`
1668	`100`	`out Signed832 velocityNumerator,`
1668	`101`	`out Signed832 velocityDenominator);`
1668	`102`	`int velocitySign =`
1668	`103`	`velocityNumerator.Sign * velocityDenominator.Sign;`
1668	`104`	`bool hasNormalVelocity = Fixed64.TryGetSignedRawRatio(`
1668	`105`	`velocityNumerator,`
1668	`106`	`velocityDenominator,`
1668	`107`	`0,`
1668	`108`	`out Fixed64 normalVelocity);`
1668	`109`	`Span<ulong> effectiveNumerator =`
1668	`110`	`stackalloc ulong[MaxResponseWords];`
1668	`111`	`Span<ulong> effectiveDenominator =`
1668	`112`	`stackalloc ulong[MaxResponseWords];`
1668	`113`	`GetEffectiveMassRatio(`
1668	`114`	`first,`
1668	`115`	`second,`
1668	`116`	`normal,`
1668	`117`	`effectiveNumerator,`
1668	`118`	`effectiveDenominator);`
	`119`
1668	`120`	`bool denominatorTooSmall =`
1668	`121`	`WideArithmetic.IsZeroMagnitude(effectiveNumerator);`
1668	`122`	`if (denominatorTooSmall)`
	`123`	`{`
14	`124`	`if (velocitySign < 0 && !includeAccumulator)`
10	`125`	`return false;`
	`126`
4	`127`	`response = CreateZeroResponse(`
4	`128`	`velocitySign < 0,`
4	`129`	`hasNormalVelocity,`
4	`130`	`normalVelocity,`
4	`131`	`includeAccumulator,`
4	`132`	`accumulatedImpulse);`
4	`133`	`return true;`
	`134`	`}`
	`135`
1654	`136`	`if (velocitySign == 0)`
	`137`	`{`
34	`138`	`response = CreateZeroResponse(`
34	`139`	`isClosing: false,`
34	`140`	`hasNormalVelocity,`
34	`141`	`normalVelocity,`
34	`142`	`includeAccumulator,`
34	`143`	`accumulatedImpulse);`
34	`144`	`return true;`
	`145`	`}`
	`146`
1620	`147`	`bool applyRestitution = velocitySign < 0`
1620	`148`	`&& (!hasNormalVelocity`
1620	`149`	`\|\| normalVelocity < -restitutionVelocityThreshold);`
1620	`150`	`Fixed64 impulseScale = velocitySign < 0`
1620	`151`	`? positiveImpulseScale`
1620	`152`	`: negativeImpulseScale;`
1620	`153`	`Span<ulong> impulseNumerator =`
1620	`154`	`stackalloc ulong[MaxResponseWords];`
1620	`155`	`Span<ulong> impulseDenominator =`
1620	`156`	`stackalloc ulong[MaxResponseWords];`
1620	`157`	`BuildImpulseRatio(`
1620	`158`	`velocityNumerator,`
1620	`159`	`velocityDenominator,`
1620	`160`	`effectiveNumerator,`
1620	`161`	`effectiveDenominator,`
1620	`162`	`applyRestitution ? restitution : Fixed64.Zero,`
1620	`163`	`impulseScale,`
1620	`164`	`impulseNumerator,`
1620	`165`	`impulseDenominator);`
1620	`166`	`int impulseSign = -velocitySign;`
	`167`
1620	`168`	`Span<ulong> appliedNumerator =`
1620	`169`	`stackalloc ulong[MaxResponseWords];`
1620	`170`	`Span<ulong> appliedDenominator =`
1620	`171`	`stackalloc ulong[MaxResponseWords];`
1620	`172`	`appliedNumerator.Clear();`
1620	`173`	`appliedDenominator.Clear();`
1620	`174`	`ResolveUnilateralImpulse(`
1620	`175`	`impulseNumerator,`
1620	`176`	`impulseDenominator,`
1620	`177`	`impulseSign,`
1620	`178`	`accumulatedImpulse,`
1620	`179`	`includeAccumulator,`
1620	`180`	`appliedNumerator,`
1620	`181`	`appliedDenominator,`
1620	`182`	`out int appliedSign,`
1620	`183`	`out bool useImpulseRatio,`
1620	`184`	`out bool hasAccumulatedProjection,`
1620	`185`	`out Fixed64 accumulatedProjection);`
	`186`
1620	`187`	`ReadOnlySpan<ulong> resolvedImpulseNumerator =`
1620	`188`	`useImpulseRatio ? impulseNumerator : appliedNumerator;`
1620	`189`	`ReadOnlySpan<ulong> resolvedImpulseDenominator =`
1620	`190`	`useImpulseRatio ? impulseDenominator : appliedDenominator;`
1620	`191`	`bool hasAppliedImpulse =`
1620	`192`	`!WideArithmetic.IsZeroMagnitude(resolvedImpulseNumerator);`
1620	`193`	`bool hasAppliedProjection = Fixed64.TryGetSignedRawRatio(`
1620	`194`	`resolvedImpulseNumerator,`
1620	`195`	`resolvedImpulseDenominator,`
1620	`196`	`appliedSign < 0,`
1620	`197`	`out Fixed64 appliedImpulse);`
1620	`198`	`bool resolved = TryGetLinearVelocityDelta(`
1620	`199`	`first.LinearImpulseAxis,`
1620	`200`	`first.InverseMass,`
1620	`201`	`resolvedImpulseNumerator,`
1620	`202`	`resolvedImpulseDenominator,`
1620	`203`	`appliedSign,`
1620	`204`	`out Vector3d firstLinear);`
1620	`205`	`resolved &= TryGetAngularVelocityDelta(`
1620	`206`	`first.Lever,`
1620	`207`	`-normal,`
1620	`208`	`first.InverseInertia,`
1620	`209`	`resolvedImpulseNumerator,`
1620	`210`	`resolvedImpulseDenominator,`
1620	`211`	`appliedSign,`
1620	`212`	`out Vector3d firstAngular);`
1620	`213`	`resolved &= TryGetLinearVelocityDelta(`
1620	`214`	`second.LinearImpulseAxis,`
1620	`215`	`second.InverseMass,`
1620	`216`	`resolvedImpulseNumerator,`
1620	`217`	`resolvedImpulseDenominator,`
1620	`218`	`appliedSign,`
1620	`219`	`out Vector3d secondLinear);`
1620	`220`	`resolved &= TryGetAngularVelocityDelta(`
1620	`221`	`second.Lever,`
1620	`222`	`normal,`
1620	`223`	`second.InverseInertia,`
1620	`224`	`resolvedImpulseNumerator,`
1620	`225`	`resolvedImpulseDenominator,`
1620	`226`	`appliedSign,`
1620	`227`	`out Vector3d secondAngular);`
1620	`228`	`if (!resolved)`
13	`229`	`return false;`
	`230`
1607	`231`	`response = new ExactNormalResponse3D(`
1607	`232`	`velocitySign < 0,`
1607	`233`	`hasAppliedImpulse,`
1607	`234`	`firstLinear,`
1607	`235`	`firstAngular,`
1607	`236`	`secondLinear,`
1607	`237`	`secondAngular,`
1607	`238`	`hasNormalVelocity,`
1607	`239`	`normalVelocity,`
1607	`240`	`hasAppliedProjection,`
1607	`241`	`appliedImpulse,`
1607	`242`	`includeAccumulator && hasAccumulatedProjection,`
1607	`243`	`accumulatedProjection);`
1607	`244`	`return true;`
	`245`	`}`
	`246`
	`247`	`private static ExactNormalResponse3D CreateZeroResponse(`
	`248`	`bool isClosing,`
	`249`	`bool hasNormalVelocity,`
	`250`	`Fixed64 normalVelocity,`
	`251`	`bool includeAccumulator,`
	`252`	`Fixed64 accumulatedImpulse) =>`
38	`253`	`new(`
38	`254`	`isClosing,`
38	`255`	`hasAppliedImpulse: false,`
38	`256`	`Vector3d.Zero,`
38	`257`	`Vector3d.Zero,`
38	`258`	`Vector3d.Zero,`
38	`259`	`Vector3d.Zero,`
38	`260`	`hasNormalVelocity,`
38	`261`	`normalVelocity,`
38	`262`	`hasAppliedImpulseProjection: true,`
38	`263`	`Fixed64.Zero,`
38	`264`	`includeAccumulator,`
38	`265`	`accumulatedImpulse);`
	`266`
	`267`	`private static void GetEffectiveMassRatio(`
	`268`	`in ExactContactResponseOperand3D first,`
	`269`	`in ExactContactResponseOperand3D second,`
	`270`	`Vector3d normal,`
	`271`	`Span<ulong> resultNumerator,`
	`272`	`Span<ulong> resultDenominator)`
	`273`	`{`
2707	`274`	`Signed192 normalSquared = GetRawDot(normal, normal);`
	`275`
2707	`276`	`Signed192 firstAllowed =`
2707	`277`	`GetRawDot(first.LinearImpulseAxis, -normal);`
2707	`278`	`Signed192 secondAllowed =`
2707	`279`	`GetRawDot(second.LinearImpulseAxis, normal);`
2707	`280`	`Signed320 linearNumerator = default;`
2707	`281`	`if (firstAllowed.Sign > 0`
2707	`282`	`&& first.InverseMass > Fixed64.Zero)`
	`283`	`{`
2506	`284`	`linearNumerator = WideArithmetic.MultiplySigned192(`
2506	`285`	`firstAllowed,`
2506	`286`	`Signed192.Raw(first.InverseMass));`
	`287`	`}`
2707	`288`	`if (secondAllowed.Sign > 0`
2707	`289`	`&& second.InverseMass > Fixed64.Zero)`
	`290`	`{`
2480	`291`	`linearNumerator = WideArithmetic.AddSigned320(`
2480	`292`	`linearNumerator,`
2480	`293`	`WideArithmetic.MultiplySigned192(`
2480	`294`	`secondAllowed,`
2480	`295`	`Signed192.Raw(second.InverseMass)));`
	`296`	`}`
	`297`
2707	`298`	`ExactLever3D.GetCrossProductQuadraticFormRatio(`
2707	`299`	`first.Lever,`
2707	`300`	`normal,`
2707	`301`	`first.InverseInertia,`
2707	`302`	`out Signed832 firstAngularNumerator,`
2707	`303`	`out Signed832 firstAngularDenominator);`
2707	`304`	`ExactLever3D.GetCrossProductQuadraticFormRatio(`
2707	`305`	`second.Lever,`
2707	`306`	`normal,`
2707	`307`	`second.InverseInertia,`
2707	`308`	`out Signed832 secondAngularNumerator,`
2707	`309`	`out Signed832 secondAngularDenominator);`
	`310`
2707	`311`	`Span<ulong> linearNumeratorMagnitude =`
2707	`312`	`stackalloc ulong[MaxResponseWords];`
2707	`313`	`Span<ulong> linearDenominatorMagnitude =`
2707	`314`	`stackalloc ulong[MaxResponseWords];`
2707	`315`	`Span<ulong> firstNumeratorMagnitude =`
2707	`316`	`stackalloc ulong[MaxResponseWords];`
2707	`317`	`Span<ulong> firstDenominatorMagnitude =`
2707	`318`	`stackalloc ulong[MaxResponseWords];`
2707	`319`	`Span<ulong> secondNumeratorMagnitude =`
2707	`320`	`stackalloc ulong[MaxResponseWords];`
2707	`321`	`Span<ulong> secondDenominatorMagnitude =`
2707	`322`	`stackalloc ulong[MaxResponseWords];`
2707	`323`	`SetMagnitude(linearNumerator, linearNumeratorMagnitude);`
2707	`324`	`SetMagnitude(normalSquared, linearDenominatorMagnitude);`
2707	`325`	`SetNonNegativeRatio(`
2707	`326`	`firstAngularNumerator,`
2707	`327`	`firstAngularDenominator,`
2707	`328`	`firstNumeratorMagnitude,`
2707	`329`	`firstDenominatorMagnitude);`
2707	`330`	`SetNonNegativeRatio(`
2707	`331`	`secondAngularNumerator,`
2707	`332`	`secondAngularDenominator,`
2707	`333`	`secondNumeratorMagnitude,`
2707	`334`	`secondDenominatorMagnitude);`
	`335`
2707	`336`	`Span<ulong> temporary = stackalloc ulong[MaxResponseWords];`
2707	`337`	`Multiply3(`
2707	`338`	`linearDenominatorMagnitude,`
2707	`339`	`firstDenominatorMagnitude,`
2707	`340`	`secondDenominatorMagnitude,`
2707	`341`	`resultDenominator);`
2707	`342`	`Multiply3(`
2707	`343`	`linearNumeratorMagnitude,`
2707	`344`	`firstDenominatorMagnitude,`
2707	`345`	`secondDenominatorMagnitude,`
2707	`346`	`resultNumerator);`
2707	`347`	`Multiply3(`
2707	`348`	`firstNumeratorMagnitude,`
2707	`349`	`linearDenominatorMagnitude,`
2707	`350`	`secondDenominatorMagnitude,`
2707	`351`	`temporary);`
2707	`352`	`WideArithmetic.AddMagnitudeInto(temporary, resultNumerator);`
2707	`353`	`Multiply3(`
2707	`354`	`secondNumeratorMagnitude,`
2707	`355`	`linearDenominatorMagnitude,`
2707	`356`	`firstDenominatorMagnitude,`
2707	`357`	`temporary);`
2707	`358`	`WideArithmetic.AddMagnitudeInto(temporary, resultNumerator);`
2707	`359`	`}`
	`360`
	`361`	`private static void BuildImpulseRatio(`
	`362`	`Signed832 velocityNumerator,`
	`363`	`Signed832 velocityDenominator,`
	`364`	`ReadOnlySpan<ulong> effectiveNumerator,`
	`365`	`ReadOnlySpan<ulong> effectiveDenominator,`
	`366`	`Fixed64 restitution,`
	`367`	`Fixed64 impulseScale,`
	`368`	`Span<ulong> numerator,`
	`369`	`Span<ulong> denominator)`
	`370`	`{`
2180	`371`	`Span<ulong> velocityNumeratorMagnitude =`
2180	`372`	`stackalloc ulong[MaxResponseWords];`
2180	`373`	`Span<ulong> velocityDenominatorMagnitude =`
2180	`374`	`stackalloc ulong[MaxResponseWords];`
2180	`375`	`Span<ulong> restitutionMagnitude =`
2180	`376`	`stackalloc ulong[MaxResponseWords];`
2180	`377`	`Span<ulong> scaleMagnitude =`
2180	`378`	`stackalloc ulong[MaxResponseWords];`
2180	`379`	`Span<ulong> fixedScale =`
2180	`380`	`stackalloc ulong[MaxResponseWords];`
2180	`381`	`SetMagnitude(velocityNumerator, velocityNumeratorMagnitude);`
2180	`382`	`SetMagnitude(velocityDenominator, velocityDenominatorMagnitude);`
2180	`383`	`SetUnsignedSum(`
2180	`384`	`(ulong)FixedMath.ONE_L,`
2180	`385`	`(ulong)restitution.m_rawValue,`
2180	`386`	`restitutionMagnitude);`
2180	`387`	`SetMagnitude(impulseScale, scaleMagnitude);`
2180	`388`	`fixedScale.Clear();`
2180	`389`	`fixedScale[0] = (ulong)FixedMath.ONE_L;`
	`390`
2180	`391`	`Multiply4(`
2180	`392`	`velocityNumeratorMagnitude,`
2180	`393`	`effectiveDenominator,`
2180	`394`	`restitutionMagnitude,`
2180	`395`	`scaleMagnitude,`
2180	`396`	`numerator);`
2180	`397`	`Multiply3(`
2180	`398`	`velocityDenominatorMagnitude,`
2180	`399`	`effectiveNumerator,`
2180	`400`	`fixedScale,`
2180	`401`	`denominator);`
2180	`402`	`}`
	`403`
	`404`	`private static void ResolveUnilateralImpulse(`
	`405`	`ReadOnlySpan<ulong> impulseNumerator,`
	`406`	`ReadOnlySpan<ulong> impulseDenominator,`
	`407`	`int impulseSign,`
	`408`	`Fixed64 accumulatedImpulse,`
	`409`	`bool includeAccumulator,`
	`410`	`Span<ulong> appliedNumerator,`
	`411`	`Span<ulong> appliedDenominator,`
	`412`	`out int appliedSign,`
	`413`	`out bool useImpulseRatio,`
	`414`	`out bool hasAccumulatedProjection,`
	`415`	`out Fixed64 accumulatedProjection)`
	`416`	`{`
1620	`417`	`appliedNumerator.Clear();`
1620	`418`	`appliedDenominator.Clear();`
1620	`419`	`useImpulseRatio = false;`
1620	`420`	`hasAccumulatedProjection = false;`
1620	`421`	`accumulatedProjection = default;`
1620	`422`	`if (!includeAccumulator)`
	`423`	`{`
189	`424`	`if (impulseSign <= 0)`
	`425`	`{`
4	`426`	`appliedDenominator[0] = 1UL;`
4	`427`	`appliedSign = 0;`
4	`428`	`return;`
	`429`	`}`
	`430`
185	`431`	`appliedSign = 1;`
185	`432`	`useImpulseRatio = true;`
185	`433`	`return;`
	`434`	`}`
	`435`
1431	`436`	`Span<ulong> accumulatorMagnitude =`
1431	`437`	`stackalloc ulong[MaxResponseWords];`
1431	`438`	`Span<ulong> accumulatedAtImpulseDenominator =`
1431	`439`	`stackalloc ulong[MaxResponseWords];`
1431	`440`	`SetMagnitude(accumulatedImpulse, accumulatorMagnitude);`
1431	`441`	`WideArithmetic.MultiplyMagnitudes(`
1431	`442`	`accumulatorMagnitude,`
1431	`443`	`impulseDenominator,`
1431	`444`	`accumulatedAtImpulseDenominator);`
1431	`445`	`if (impulseSign < 0`
1431	`446`	`&& WideArithmetic.CompareMagnitudeEqualLength(`
1431	`447`	`impulseNumerator,`
1431	`448`	`accumulatedAtImpulseDenominator) >= 0)`
	`449`	`{`
359	`450`	`accumulatorMagnitude.CopyTo(appliedNumerator);`
359	`451`	`appliedDenominator[0] = 1UL;`
359	`452`	`appliedSign = WideArithmetic.IsZeroMagnitude(`
359	`453`	`accumulatorMagnitude)`
359	`454`	`? 0`
359	`455`	`: -1;`
359	`456`	`hasAccumulatedProjection = true;`
359	`457`	`accumulatedProjection = Fixed64.Zero;`
359	`458`	`return;`
	`459`	`}`
	`460`
1072	`461`	`Span<ulong> completedAccumulator =`
1072	`462`	`stackalloc ulong[MaxResponseWords];`
1072	`463`	`if (impulseSign > 0)`
	`464`	`{`
876	`465`	`accumulatedAtImpulseDenominator.CopyTo(completedAccumulator);`
876	`466`	`WideArithmetic.AddMagnitudeInto(`
876	`467`	`impulseNumerator,`
876	`468`	`completedAccumulator);`
	`469`	`}`
	`470`	`else`
	`471`	`{`
196	`472`	`WideArithmetic.SubtractEqualMagnitudes(`
196	`473`	`accumulatedAtImpulseDenominator,`
196	`474`	`impulseNumerator,`
196	`475`	`completedAccumulator);`
	`476`	`}`
	`477`
1072	`478`	`hasAccumulatedProjection = Fixed64.TryGetSignedRawRatio(`
1072	`479`	`completedAccumulator,`
1072	`480`	`impulseDenominator,`
1072	`481`	`negative: false,`
1072	`482`	`out accumulatedProjection);`
1072	`483`	`appliedSign = impulseSign;`
1072	`484`	`useImpulseRatio = true;`
1072	`485`	`}`
	`486`
	`487`	`private static bool TryGetLinearVelocityDelta(`
	`488`	`Vector3d impulseAxis,`
	`489`	`Fixed64 inverseMass,`
	`490`	`ReadOnlySpan<ulong> impulseNumerator,`
	`491`	`ReadOnlySpan<ulong> impulseDenominator,`
	`492`	`int impulseSign,`
	`493`	`out Vector3d result)`
	`494`	`{`
3346	`495`	`if (inverseMass == Fixed64.Zero`
3346	`496`	`\|\| impulseAxis == Vector3d.Zero`
3346	`497`	`\|\| WideArithmetic.IsZeroMagnitude(impulseNumerator))`
	`498`	`{`
978	`499`	`result = Vector3d.Zero;`
978	`500`	`return true;`
	`501`	`}`
	`502`
2368	`503`	`bool xResolved = TryGetLinearComponent(`
2368	`504`	`impulseAxis.X,`
2368	`505`	`inverseMass,`
2368	`506`	`impulseNumerator,`
2368	`507`	`impulseDenominator,`
2368	`508`	`impulseSign,`
2368	`509`	`out Fixed64 x);`
2368	`510`	`bool yResolved = TryGetLinearComponent(`
2368	`511`	`impulseAxis.Y,`
2368	`512`	`inverseMass,`
2368	`513`	`impulseNumerator,`
2368	`514`	`impulseDenominator,`
2368	`515`	`impulseSign,`
2368	`516`	`out Fixed64 y);`
2368	`517`	`bool zResolved = TryGetLinearComponent(`
2368	`518`	`impulseAxis.Z,`
2368	`519`	`inverseMass,`
2368	`520`	`impulseNumerator,`
2368	`521`	`impulseDenominator,`
2368	`522`	`impulseSign,`
2368	`523`	`out Fixed64 z);`
2368	`524`	`result = xResolved & yResolved & zResolved`
2368	`525`	`? new Vector3d(x, y, z)`
2368	`526`	`: default;`
2368	`527`	`return xResolved & yResolved & zResolved;`
	`528`	`}`
	`529`
	`530`	`private static bool TryGetLinearComponent(`
	`531`	`Fixed64 axis,`
	`532`	`Fixed64 inverseMass,`
	`533`	`ReadOnlySpan<ulong> impulseNumerator,`
	`534`	`ReadOnlySpan<ulong> impulseDenominator,`
	`535`	`int impulseSign,`
	`536`	`out Fixed64 result)`
	`537`	`{`
7104	`538`	`if (axis == Fixed64.Zero)`
	`539`	`{`
4578	`540`	`result = Fixed64.Zero;`
4578	`541`	`return true;`
	`542`	`}`
	`543`
2526	`544`	`Span<ulong> axisMagnitude =`
2526	`545`	`stackalloc ulong[MaxResponseWords];`
2526	`546`	`Span<ulong> inverseMassMagnitude =`
2526	`547`	`stackalloc ulong[MaxResponseWords];`
2526	`548`	`Span<ulong> fixedScale =`
2526	`549`	`stackalloc ulong[MaxResponseWords];`
2526	`550`	`Span<ulong> numerator =`
2526	`551`	`stackalloc ulong[MaxResponseWords];`
2526	`552`	`Span<ulong> denominator =`
2526	`553`	`stackalloc ulong[MaxResponseWords];`
2526	`554`	`SetMagnitude(axis, axisMagnitude);`
2526	`555`	`SetMagnitude(inverseMass, inverseMassMagnitude);`
2526	`556`	`fixedScale.Clear();`
2526	`557`	`fixedScale[0] = (ulong)FixedMath.ONE_L;`
2526	`558`	`Multiply3(`
2526	`559`	`axisMagnitude,`
2526	`560`	`inverseMassMagnitude,`
2526	`561`	`impulseNumerator,`
2526	`562`	`numerator);`
2526	`563`	`Multiply3(`
2526	`564`	`impulseDenominator,`
2526	`565`	`fixedScale,`
2526	`566`	`fixedScale,`
2526	`567`	`denominator);`
2526	`568`	`return Fixed64.TryGetSignedRawRatio(`
2526	`569`	`numerator,`
2526	`570`	`denominator,`
2526	`571`	`(axis < Fixed64.Zero) != (impulseSign < 0),`
2526	`572`	`out result);`
	`573`	`}`
	`574`
	`575`	`private static bool TryGetAngularVelocityDelta(`
	`576`	`in ExactLever3D lever,`
	`577`	`Vector3d impulseAxis,`
	`578`	`Fixed3x3 inverseInertia,`
	`579`	`ReadOnlySpan<ulong> impulseNumerator,`
	`580`	`ReadOnlySpan<ulong> impulseDenominator,`
	`581`	`int impulseSign,`
	`582`	`out Vector3d result)`
	`583`	`{`
3346	`584`	`if (WideArithmetic.IsZeroMagnitude(impulseNumerator))`
	`585`	`{`
738	`586`	`result = Vector3d.Zero;`
738	`587`	`return true;`
	`588`	`}`
	`589`
2608	`590`	`ExactLever3D.GetTransformedCrossProduct(`
2608	`591`	`lever,`
2608	`592`	`impulseAxis,`
2608	`593`	`inverseInertia,`
2608	`594`	`out Signed832 transformedX,`
2608	`595`	`out Signed832 transformedY,`
2608	`596`	`out Signed832 transformedZ);`
2608	`597`	`Signed320 fixedScaleSquared = WideArithmetic.MultiplySigned192(`
2608	`598`	`Signed192.One,`
2608	`599`	`Signed192.One);`
2608	`600`	`Signed704 transformedDenominator =`
2608	`601`	`WideArithmetic.MultiplySigned576ToSigned704(`
2608	`602`	`lever.Denominator,`
2608	`603`	`fixedScaleSquared);`
2608	`604`	`bool xResolved = TryGetAngularComponent(`
2608	`605`	`transformedX,`
2608	`606`	`transformedDenominator,`
2608	`607`	`impulseNumerator,`
2608	`608`	`impulseDenominator,`
2608	`609`	`impulseSign,`
2608	`610`	`out Fixed64 x);`
2608	`611`	`bool yResolved = TryGetAngularComponent(`
2608	`612`	`transformedY,`
2608	`613`	`transformedDenominator,`
2608	`614`	`impulseNumerator,`
2608	`615`	`impulseDenominator,`
2608	`616`	`impulseSign,`
2608	`617`	`out Fixed64 y);`
2608	`618`	`bool zResolved = TryGetAngularComponent(`
2608	`619`	`transformedZ,`
2608	`620`	`transformedDenominator,`
2608	`621`	`impulseNumerator,`
2608	`622`	`impulseDenominator,`
2608	`623`	`impulseSign,`
2608	`624`	`out Fixed64 z);`
2608	`625`	`result = xResolved & yResolved & zResolved`
2608	`626`	`? new Vector3d(x, y, z)`
2608	`627`	`: default;`
2608	`628`	`return xResolved & yResolved & zResolved;`
	`629`	`}`
	`630`
	`631`	`private static bool TryGetAngularComponent(`
	`632`	`Signed832 transformed,`
	`633`	`Signed704 transformedDenominator,`
	`634`	`ReadOnlySpan<ulong> impulseNumerator,`
	`635`	`ReadOnlySpan<ulong> impulseDenominator,`
	`636`	`int impulseSign,`
	`637`	`out Fixed64 result)`
	`638`	`{`
7824	`639`	`if (transformed.Sign == 0)`
	`640`	`{`
5682	`641`	`result = Fixed64.Zero;`
5682	`642`	`return true;`
	`643`	`}`
	`644`
2142	`645`	`Span<ulong> transformedMagnitude =`
2142	`646`	`stackalloc ulong[MaxResponseWords];`
2142	`647`	`Span<ulong> transformedDenominatorMagnitude =`
2142	`648`	`stackalloc ulong[MaxResponseWords];`
2142	`649`	`Span<ulong> fixedScale =`
2142	`650`	`stackalloc ulong[MaxResponseWords];`
2142	`651`	`Span<ulong> numerator =`
2142	`652`	`stackalloc ulong[MaxResponseWords];`
2142	`653`	`Span<ulong> denominator =`
2142	`654`	`stackalloc ulong[MaxResponseWords];`
2142	`655`	`SetMagnitude(transformed, transformedMagnitude);`
2142	`656`	`SetMagnitude(transformedDenominator, transformedDenominatorMagnitude);`
2142	`657`	`fixedScale.Clear();`
2142	`658`	`fixedScale[0] = (ulong)FixedMath.ONE_L;`
2142	`659`	`WideArithmetic.MultiplyMagnitudes(`
2142	`660`	`transformedMagnitude,`
2142	`661`	`impulseNumerator,`
2142	`662`	`numerator);`
2142	`663`	`Multiply3(`
2142	`664`	`transformedDenominatorMagnitude,`
2142	`665`	`impulseDenominator,`
2142	`666`	`fixedScale,`
2142	`667`	`denominator);`
2142	`668`	`return Fixed64.TryGetSignedRawRatio(`
2142	`669`	`numerator,`
2142	`670`	`denominator,`
2142	`671`	`(transformed.Sign < 0) != (impulseSign < 0),`
2142	`672`	`out result);`
	`673`	`}`
	`674`
	`675`	`private static Signed192 GetRawDot(Vector3d left, Vector3d right) =>`
8121	`676`	`WideGeometry.GetDifferenceDotProduct3D(`
8121	`677`	`left.X,`
8121	`678`	`Fixed64.Zero,`
8121	`679`	`left.Y,`
8121	`680`	`Fixed64.Zero,`
8121	`681`	`left.Z,`
8121	`682`	`Fixed64.Zero,`
8121	`683`	`right.X,`
8121	`684`	`Fixed64.Zero,`
8121	`685`	`right.Y,`
8121	`686`	`Fixed64.Zero,`
8121	`687`	`right.Z,`
8121	`688`	`Fixed64.Zero);`
	`689`
	`690`	`private static void SetNonNegativeRatio(`
	`691`	`Signed832 numerator,`
	`692`	`Signed832 denominator,`
	`693`	`Span<ulong> numeratorMagnitude,`
	`694`	`Span<ulong> denominatorMagnitude)`
	`695`	`{`
5414	`696`	`numeratorMagnitude.Clear();`
5414	`697`	`denominatorMagnitude.Clear();`
5414	`698`	`if (numerator.Sign <= 0)`
	`699`	`{`
1158	`700`	`denominatorMagnitude[0] = 1UL;`
1158	`701`	`return;`
	`702`	`}`
	`703`
4256	`704`	`SetMagnitude(numerator, numeratorMagnitude);`
4256	`705`	`SetMagnitude(denominator, denominatorMagnitude);`
4256	`706`	`}`
	`707`
	`708`	`private static void SetUnsignedSum(`
	`709`	`ulong first,`
	`710`	`ulong second,`
	`711`	`Span<ulong> result)`
	`712`	`{`
2180	`713`	`result.Clear();`
2180	`714`	`result[0] = unchecked(first + second);`
2180	`715`	`}`
	`716`
	`717`	`private static void SetMagnitude(`
	`718`	`Fixed64 value,`
	`719`	`Span<ulong> result)`
	`720`	`{`
27143	`721`	`result.Clear();`
27143	`722`	`WideArithmetic.GetMagnitude(`
27143	`723`	`Signed192.Raw(value),`
27143	`724`	`out result[2],`
27143	`725`	`out result[1],`
27143	`726`	`out result[0]);`
27143	`727`	`}`
	`728`
	`729`	`private static void SetMagnitude(`
	`730`	`Signed192 value,`
	`731`	`Span<ulong> result)`
	`732`	`{`
2707	`733`	`result.Clear();`
2707	`734`	`WideArithmetic.GetMagnitude(`
2707	`735`	`value,`
2707	`736`	`out result[2],`
2707	`737`	`out result[1],`
2707	`738`	`out result[0]);`
2707	`739`	`}`
	`740`
	`741`	`private static void SetMagnitude(`
	`742`	`Signed320 value,`
	`743`	`Span<ulong> result)`
	`744`	`{`
2707	`745`	`result.Clear();`
2707	`746`	`WideArithmetic.GetMagnitude(`
2707	`747`	`value,`
2707	`748`	`out result[4],`
2707	`749`	`out result[3],`
2707	`750`	`out result[2],`
2707	`751`	`out result[1],`
2707	`752`	`out result[0]);`
2707	`753`	`}`
	`754`
	`755`	`private static void SetMagnitude(`
	`756`	`Signed704 value,`
	`757`	`Span<ulong> result)`
	`758`	`{`
4776	`759`	`result.Clear();`
4776	`760`	`WideArithmetic.GetMagnitude(value, result);`
4776	`761`	`}`
	`762`
	`763`	`private static void SetMagnitude(`
	`764`	`Signed832 value,`
	`765`	`Span<ulong> result)`
	`766`	`{`
22886	`767`	`result.Clear();`
22886	`768`	`WideArithmetic.GetMagnitude(value, result);`
22886	`769`	`}`
	`770`
	`771`	`private static void Multiply3(`
	`772`	`ReadOnlySpan<ulong> first,`
	`773`	`ReadOnlySpan<ulong> second,`
	`774`	`ReadOnlySpan<ulong> third,`
	`775`	`Span<ulong> result)`
	`776`	`{`
25377	`777`	`Span<ulong> temporary =`
25377	`778`	`stackalloc ulong[result.Length];`
25377	`779`	`WideArithmetic.MultiplyMagnitudes(first, second, temporary);`
25377	`780`	`WideArithmetic.MultiplyMagnitudes(temporary, third, result);`
25377	`781`	`}`
	`782`
	`783`	`private static void Multiply4(`
	`784`	`ReadOnlySpan<ulong> first,`
	`785`	`ReadOnlySpan<ulong> second,`
	`786`	`ReadOnlySpan<ulong> third,`
	`787`	`ReadOnlySpan<ulong> fourth,`
	`788`	`Span<ulong> result)`
	`789`	`{`
2180	`790`	`Span<ulong> firstProduct =`
2180	`791`	`stackalloc ulong[MaxResponseWords];`
2180	`792`	`Span<ulong> secondProduct =`
2180	`793`	`stackalloc ulong[MaxResponseWords];`
2180	`794`	`WideArithmetic.MultiplyMagnitudes(first, second, firstProduct);`
2180	`795`	`WideArithmetic.MultiplyMagnitudes(third, fourth, secondProduct);`
2180	`796`	`WideArithmetic.MultiplyMagnitudes(`
2180	`797`	`firstProduct,`
2180	`798`	`secondProduct,`
2180	`799`	`result);`
2180	`800`	`}`
	`801`
	`802`	`}`

Methods/Properties