< Summary

Information

Class:	FixedMathSharp.Geometry.WidePointAnchor3d
Assembly:	FixedMathSharp
File(s):	File 1: /home/runner/work/FixedMathSharp/FixedMathSharp/src/FixedMathSharp/Geometry/Anchors/Wide/WidePointAnchor3d.cs File 2: /home/runner/work/FixedMathSharp/FixedMathSharp/src/FixedMathSharp/Geometry/Anchors/Wide/WidePointAnchor3d.Distance.cs File 3: /home/runner/work/FixedMathSharp/FixedMathSharp/src/FixedMathSharp/Geometry/Anchors/Wide/WidePointAnchor3d.Exact.cs

Line coverage

100%

Covered lines:	1158
Uncovered lines:	0
Coverable lines:	1158
Total lines:	1640
Line coverage:	100%

Branch coverage

100%

Covered branches:	92
Total branches:	92
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: TryGetPoint(...)	100%	2	2	100%
File 1: TryGetRelativeOffset(...)	100%	22	22	100%
File 1: TryScaleOffset(...)	100%	4	4	100%
File 1: TryGetLocalPointIn(...)	100%	2	2	100%
File 1: TryGetProjectedOffset(...)	100%	1	1	100%
File 1: ProjectNonNegativeOffset(...)	100%	1	1	100%
File 1: GetProjectedOffsetRatio(...)	100%	4	4	100%
File 1: GetProjectedOffsetRatio(...)	100%	1	1	100%
File 1: TryGetPointCoordinate(...)	100%	1	1	100%
File 1: TryGetRelativeOffsetCoordinate(...)	100%	2	2	100%
File 1: GetRelativeOffsetNumerator(...)	100%	1	1	100%
File 1: TryGetLocalPointCoordinate(...)	100%	1	1	100%
File 2: GetDirection(...)	100%	1	1	100%
File 2: CompareSquaredDistances(...)	100%	12	12	100%
File 2: CompareExactSquaredDistances(...)	100%	1	1	100%
File 2: GetExactSquaredOffsetRatio(...)	100%	1	1	100%
File 2: GetSquaredOffsetRatio(...)	100%	1	1	100%
File 3: TryGetPoint(...)	100%	6	6	100%
File 3: TryGetRelativeOffset(...)	100%	10	10	100%
File 3: RepresentsSamePoint(...)	100%	4	4	100%
File 3: TryGetLocalPointIn(...)	100%	6	6	100%
File 3: TryGetProjectedOffset(...)	100%	8	8	100%
File 3: ProjectNonNegativeOffset(...)	100%	8	8	100%
File 3: GetExactProjectedOffsetRatio(...)	100%	1	1	100%
File 3: GetExactRelativeOffsetRatio(...)	100%	1	1	100%
File 3: GetExactRelativeOffsetNumerator(...)	100%	1	1	100%
File 3: GetAnchorCoordinateNumerator(...)	100%	1	1	100%
File 3: GetAnchorDenominator(...)	100%	1	1	100%
File 3: GetAnchorDeltaNumerator(...)	100%	1	1	100%
File 3: GetWideProjection(...)	100%	1	1	100%
File 3: TryGetScaledExactCoordinate(...)	100%	2	2	100%

File(s)

/home/runner/work/FixedMathSharp/FixedMathSharp/src/FixedMathSharp/Geometry/Anchors/Wide/WidePointAnchor3d.cs

#	Line	Line coverage
	`1`	`//=======================================================================`
	`2`	`// WidePointAnchor3d.cs`
	`3`	`//=======================================================================`
	`4`	`// MIT License, Copyright (c) 2024–present David Oravsky (mrdav30)`
	`5`	`// See LICENSE file in the project root for full license information.`
	`6`	`//=======================================================================`
	`7`
	`8`	`namespace FixedMathSharp.Geometry;`
	`9`
	`10`	`/// <summary>`
	`11`	`/// Provides high-precision (wide/extended) arithmetic helpers for resolving anchored 3D points`
	`12`	`/// and their relative offsets under rotation, avoiding precision loss from repeated fixed-point operations.`
	`13`	`/// </summary>`
	`14`	`internal static partial class WidePointAnchor3d`
	`15`	`{`
	`16`	`internal static bool TryGetPoint(`
	`17`	`Vector3d origin,`
	`18`	`FixedQuaternion rotation,`
	`19`	`Vector3d localPoint,`
	`20`	`Vector3d localDisplacement,`
	`21`	`out Vector3d point)`
	`22`	`{`
604	`23`	`WideRationalBasis3d basis = new(rotation);`
604	`24`	`Signed576 denominator =`
604	`25`	`Signed576.ExtendValue(`
604	`26`	`Signed320.ExtendValue(basis.Denominator));`
604	`27`	`bool representable = TryGetPointCoordinate(`
604	`28`	`origin.X,`
604	`29`	`basis.Xx,`
604	`30`	`basis.Yx,`
604	`31`	`basis.Zx,`
604	`32`	`basis.Denominator,`
604	`33`	`denominator,`
604	`34`	`localPoint,`
604	`35`	`localDisplacement,`
604	`36`	`out Fixed64 x)`
604	`37`	`& TryGetPointCoordinate(`
604	`38`	`origin.Y,`
604	`39`	`basis.Xy,`
604	`40`	`basis.Yy,`
604	`41`	`basis.Zy,`
604	`42`	`basis.Denominator,`
604	`43`	`denominator,`
604	`44`	`localPoint,`
604	`45`	`localDisplacement,`
604	`46`	`out Fixed64 y)`
604	`47`	`& TryGetPointCoordinate(`
604	`48`	`origin.Z,`
604	`49`	`basis.Xz,`
604	`50`	`basis.Yz,`
604	`51`	`basis.Zz,`
604	`52`	`basis.Denominator,`
604	`53`	`denominator,`
604	`54`	`localPoint,`
604	`55`	`localDisplacement,`
604	`56`	`out Fixed64 z);`
604	`57`	`if (!representable)`
	`58`	`{`
32	`59`	`point = default;`
32	`60`	`return false;`
	`61`	`}`
	`62`
572	`63`	`point = new Vector3d(x, y, z);`
572	`64`	`return true;`
	`65`	`}`
	`66`
	`67`	`internal static bool TryGetRelativeOffset(`
	`68`	`Vector3d firstOrigin,`
	`69`	`FixedQuaternion firstRotation,`
	`70`	`Vector3d firstLocalPoint,`
	`71`	`Vector3d firstLocalDisplacement,`
	`72`	`Vector3d secondOrigin,`
	`73`	`FixedQuaternion secondRotation,`
	`74`	`Vector3d secondLocalPoint,`
	`75`	`Vector3d secondLocalDisplacement,`
	`76`	`Fixed64 scale,`
	`77`	`out Vector3d offset)`
	`78`	`{`
1396	`79`	`if (firstOrigin == secondOrigin`
1396	`80`	`&& firstRotation == secondRotation)`
	`81`	`{`
	`82`	`bool localRepresentable;`
	`83`	`Vector3d localOffset;`
1049	`84`	`if (firstLocalDisplacement == Vector3d.Zero`
1049	`85`	`&& secondLocalDisplacement == Vector3d.Zero)`
	`86`	`{`
1028	`87`	`localRepresentable = Vector3d.TrySubtract(`
1028	`88`	`firstLocalPoint,`
1028	`89`	`secondLocalPoint,`
1028	`90`	`out localOffset);`
	`91`	`}`
	`92`	`else`
	`93`	`{`
21	`94`	`localRepresentable = Vector3d.TrySubtractSums(`
21	`95`	`firstLocalPoint,`
21	`96`	`firstLocalDisplacement,`
21	`97`	`secondLocalPoint,`
21	`98`	`secondLocalDisplacement,`
21	`99`	`out localOffset);`
	`100`	`}`
	`101`
1049	`102`	`if (localRepresentable)`
	`103`	`{`
1048	`104`	`if (firstRotation != FixedQuaternion.Identity)`
	`105`	`{`
3	`106`	`if (scale == Fixed64.One)`
2	`107`	`return firstRotation.TryRotate(localOffset, out offset);`
	`108`	`}`
	`109`	`else`
	`110`	`{`
1045	`111`	`return TryScaleOffset(localOffset, scale, out offset);`
	`112`	`}`
	`113`	`}`
	`114`	`}`
	`115`
349	`116`	`if (firstRotation == FixedQuaternion.Identity`
349	`117`	`&& secondRotation == FixedQuaternion.Identity)`
	`118`	`{`
68	`119`	`bool compactRepresentable = Vector3d.TryAddSubtract(`
68	`120`	`firstOrigin,`
68	`121`	`firstLocalPoint,`
68	`122`	`secondOrigin,`
68	`123`	`out Vector3d firstStep);`
68	`124`	`compactRepresentable &= Vector3d.TryAddSubtract(`
68	`125`	`firstStep,`
68	`126`	`firstLocalDisplacement,`
68	`127`	`secondLocalPoint,`
68	`128`	`out Vector3d secondStep);`
68	`129`	`compactRepresentable &= Vector3d.TrySubtract(`
68	`130`	`secondStep,`
68	`131`	`secondLocalDisplacement,`
68	`132`	`out Vector3d compactOffset);`
68	`133`	`if (compactRepresentable)`
55	`134`	`return TryScaleOffset(compactOffset, scale, out offset);`
	`135`	`}`
	`136`
294	`137`	`WideRationalBasis3d firstBasis = new(firstRotation);`
294	`138`	`WideRationalBasis3d secondBasis = new(secondRotation);`
294	`139`	`Signed320 denominator = WideArithmetic.MultiplySigned192(`
294	`140`	`firstBasis.Denominator,`
294	`141`	`secondBasis.Denominator);`
294	`142`	`Signed576 denominatorWide = Signed576.ExtendValue(denominator);`
294	`143`	`bool representable = TryGetRelativeOffsetCoordinate(`
294	`144`	`firstOrigin.X,`
294	`145`	`firstBasis.Xx,`
294	`146`	`firstBasis.Yx,`
294	`147`	`firstBasis.Zx,`
294	`148`	`firstBasis.Denominator,`
294	`149`	`firstLocalPoint,`
294	`150`	`firstLocalDisplacement,`
294	`151`	`secondOrigin.X,`
294	`152`	`secondBasis.Xx,`
294	`153`	`secondBasis.Yx,`
294	`154`	`secondBasis.Zx,`
294	`155`	`secondBasis.Denominator,`
294	`156`	`secondLocalPoint,`
294	`157`	`secondLocalDisplacement,`
294	`158`	`denominator,`
294	`159`	`denominatorWide,`
294	`160`	`scale,`
294	`161`	`out Fixed64 x)`
294	`162`	`& TryGetRelativeOffsetCoordinate(`
294	`163`	`firstOrigin.Y,`
294	`164`	`firstBasis.Xy,`
294	`165`	`firstBasis.Yy,`
294	`166`	`firstBasis.Zy,`
294	`167`	`firstBasis.Denominator,`
294	`168`	`firstLocalPoint,`
294	`169`	`firstLocalDisplacement,`
294	`170`	`secondOrigin.Y,`
294	`171`	`secondBasis.Xy,`
294	`172`	`secondBasis.Yy,`
294	`173`	`secondBasis.Zy,`
294	`174`	`secondBasis.Denominator,`
294	`175`	`secondLocalPoint,`
294	`176`	`secondLocalDisplacement,`
294	`177`	`denominator,`
294	`178`	`denominatorWide,`
294	`179`	`scale,`
294	`180`	`out Fixed64 y)`
294	`181`	`& TryGetRelativeOffsetCoordinate(`
294	`182`	`firstOrigin.Z,`
294	`183`	`firstBasis.Xz,`
294	`184`	`firstBasis.Yz,`
294	`185`	`firstBasis.Zz,`
294	`186`	`firstBasis.Denominator,`
294	`187`	`firstLocalPoint,`
294	`188`	`firstLocalDisplacement,`
294	`189`	`secondOrigin.Z,`
294	`190`	`secondBasis.Xz,`
294	`191`	`secondBasis.Yz,`
294	`192`	`secondBasis.Zz,`
294	`193`	`secondBasis.Denominator,`
294	`194`	`secondLocalPoint,`
294	`195`	`secondLocalDisplacement,`
294	`196`	`denominator,`
294	`197`	`denominatorWide,`
294	`198`	`scale,`
294	`199`	`out Fixed64 z);`
294	`200`	`if (!representable)`
	`201`	`{`
8	`202`	`offset = default;`
8	`203`	`return false;`
	`204`	`}`
	`205`
286	`206`	`offset = new Vector3d(x, y, z);`
286	`207`	`return true;`
	`208`	`}`
	`209`
	`210`	`private static bool TryScaleOffset(`
	`211`	`Vector3d value,`
	`212`	`Fixed64 scale,`
	`213`	`out Vector3d result)`
	`214`	`{`
1100	`215`	`if (scale == Fixed64.One)`
	`216`	`{`
1094	`217`	`result = value;`
1094	`218`	`return true;`
	`219`	`}`
	`220`
6	`221`	`bool representable = Fixed64.TryMultiplyDivide(`
6	`222`	`value.X,`
6	`223`	`scale,`
6	`224`	`Fixed64.One,`
6	`225`	`out Fixed64 x)`
6	`226`	`& Fixed64.TryMultiplyDivide(`
6	`227`	`value.Y,`
6	`228`	`scale,`
6	`229`	`Fixed64.One,`
6	`230`	`out Fixed64 y)`
6	`231`	`& Fixed64.TryMultiplyDivide(`
6	`232`	`value.Z,`
6	`233`	`scale,`
6	`234`	`Fixed64.One,`
6	`235`	`out Fixed64 z);`
6	`236`	`result = representable ? new Vector3d(x, y, z) : default;`
6	`237`	`return representable;`
	`238`	`}`
	`239`
	`240`	`internal static bool TryGetLocalPointIn(`
	`241`	`Vector3d pointOrigin,`
	`242`	`FixedQuaternion pointRotation,`
	`243`	`Vector3d pointLocalPoint,`
	`244`	`Vector3d pointLocalDisplacement,`
	`245`	`Vector3d frameOrigin,`
	`246`	`FixedQuaternion frameRotation,`
	`247`	`out Vector3d localPoint)`
	`248`	`{`
4475	`249`	`WideRationalBasis3d pointBasis = new(pointRotation);`
4475	`250`	`WideRationalBasis3d frameBasis = new(frameRotation);`
4475	`251`	`Signed320 denominator = WideArithmetic.MultiplySigned192(`
4475	`252`	`pointBasis.Denominator,`
4475	`253`	`frameBasis.Denominator);`
4475	`254`	`Signed576 denominatorWide = Signed576.ExtendValue(denominator);`
4475	`255`	`Signed192 originX = WideArithmetic.SubtractSigned192(`
4475	`256`	`Signed192.Raw(pointOrigin.X),`
4475	`257`	`Signed192.Raw(frameOrigin.X));`
4475	`258`	`Signed192 originY = WideArithmetic.SubtractSigned192(`
4475	`259`	`Signed192.Raw(pointOrigin.Y),`
4475	`260`	`Signed192.Raw(frameOrigin.Y));`
4475	`261`	`Signed192 originZ = WideArithmetic.SubtractSigned192(`
4475	`262`	`Signed192.Raw(pointOrigin.Z),`
4475	`263`	`Signed192.Raw(frameOrigin.Z));`
4475	`264`	`Signed320 rotatedX = WideArithmetic.GetDotProduct3D(`
4475	`265`	`Signed192.Raw(pointLocalPoint.X),`
4475	`266`	`Signed192.Raw(pointLocalPoint.Y),`
4475	`267`	`Signed192.Raw(pointLocalPoint.Z),`
4475	`268`	`pointBasis.Xx,`
4475	`269`	`pointBasis.Yx,`
4475	`270`	`pointBasis.Zx);`
4475	`271`	`rotatedX = WideArithmetic.AddSigned320(`
4475	`272`	`rotatedX,`
4475	`273`	`WideArithmetic.GetDotProduct3D(`
4475	`274`	`Signed192.Raw(pointLocalDisplacement.X),`
4475	`275`	`Signed192.Raw(pointLocalDisplacement.Y),`
4475	`276`	`Signed192.Raw(pointLocalDisplacement.Z),`
4475	`277`	`pointBasis.Xx,`
4475	`278`	`pointBasis.Yx,`
4475	`279`	`pointBasis.Zx));`
4475	`280`	`Signed320 rotatedY = WideArithmetic.GetDotProduct3D(`
4475	`281`	`Signed192.Raw(pointLocalPoint.X),`
4475	`282`	`Signed192.Raw(pointLocalPoint.Y),`
4475	`283`	`Signed192.Raw(pointLocalPoint.Z),`
4475	`284`	`pointBasis.Xy,`
4475	`285`	`pointBasis.Yy,`
4475	`286`	`pointBasis.Zy);`
4475	`287`	`rotatedY = WideArithmetic.AddSigned320(`
4475	`288`	`rotatedY,`
4475	`289`	`WideArithmetic.GetDotProduct3D(`
4475	`290`	`Signed192.Raw(pointLocalDisplacement.X),`
4475	`291`	`Signed192.Raw(pointLocalDisplacement.Y),`
4475	`292`	`Signed192.Raw(pointLocalDisplacement.Z),`
4475	`293`	`pointBasis.Xy,`
4475	`294`	`pointBasis.Yy,`
4475	`295`	`pointBasis.Zy));`
4475	`296`	`Signed320 rotatedZ = WideArithmetic.GetDotProduct3D(`
4475	`297`	`Signed192.Raw(pointLocalPoint.X),`
4475	`298`	`Signed192.Raw(pointLocalPoint.Y),`
4475	`299`	`Signed192.Raw(pointLocalPoint.Z),`
4475	`300`	`pointBasis.Xz,`
4475	`301`	`pointBasis.Yz,`
4475	`302`	`pointBasis.Zz);`
4475	`303`	`rotatedZ = WideArithmetic.AddSigned320(`
4475	`304`	`rotatedZ,`
4475	`305`	`WideArithmetic.GetDotProduct3D(`
4475	`306`	`Signed192.Raw(pointLocalDisplacement.X),`
4475	`307`	`Signed192.Raw(pointLocalDisplacement.Y),`
4475	`308`	`Signed192.Raw(pointLocalDisplacement.Z),`
4475	`309`	`pointBasis.Xz,`
4475	`310`	`pointBasis.Yz,`
4475	`311`	`pointBasis.Zz));`
	`312`
4475	`313`	`bool representable = TryGetLocalPointCoordinate(`
4475	`314`	`originX,`
4475	`315`	`originY,`
4475	`316`	`originZ,`
4475	`317`	`rotatedX,`
4475	`318`	`rotatedY,`
4475	`319`	`rotatedZ,`
4475	`320`	`pointBasis.Denominator,`
4475	`321`	`frameBasis.Xx,`
4475	`322`	`frameBasis.Xy,`
4475	`323`	`frameBasis.Xz,`
4475	`324`	`denominatorWide,`
4475	`325`	`out Fixed64 x)`
4475	`326`	`& TryGetLocalPointCoordinate(`
4475	`327`	`originX,`
4475	`328`	`originY,`
4475	`329`	`originZ,`
4475	`330`	`rotatedX,`
4475	`331`	`rotatedY,`
4475	`332`	`rotatedZ,`
4475	`333`	`pointBasis.Denominator,`
4475	`334`	`frameBasis.Yx,`
4475	`335`	`frameBasis.Yy,`
4475	`336`	`frameBasis.Yz,`
4475	`337`	`denominatorWide,`
4475	`338`	`out Fixed64 y)`
4475	`339`	`& TryGetLocalPointCoordinate(`
4475	`340`	`originX,`
4475	`341`	`originY,`
4475	`342`	`originZ,`
4475	`343`	`rotatedX,`
4475	`344`	`rotatedY,`
4475	`345`	`rotatedZ,`
4475	`346`	`pointBasis.Denominator,`
4475	`347`	`frameBasis.Zx,`
4475	`348`	`frameBasis.Zy,`
4475	`349`	`frameBasis.Zz,`
4475	`350`	`denominatorWide,`
4475	`351`	`out Fixed64 z);`
4475	`352`	`if (!representable)`
	`353`	`{`
15	`354`	`localPoint = default;`
15	`355`	`return false;`
	`356`	`}`
	`357`
4460	`358`	`localPoint = new Vector3d(x, y, z);`
4460	`359`	`return true;`
	`360`	`}`
	`361`
	`362`	`internal static bool TryGetProjectedOffset(`
	`363`	`Vector3d firstOrigin,`
	`364`	`FixedQuaternion firstRotation,`
	`365`	`Vector3d firstLocalPoint,`
	`366`	`Vector3d firstLocalDisplacement,`
	`367`	`Vector3d secondOrigin,`
	`368`	`FixedQuaternion secondRotation,`
	`369`	`Vector3d secondLocalPoint,`
	`370`	`Vector3d secondLocalDisplacement,`
	`371`	`Vector3d direction,`
	`372`	`out Fixed64 projection)`
	`373`	`{`
261	`374`	`GetProjectedOffsetRatio(`
261	`375`	`firstOrigin,`
261	`376`	`firstRotation,`
261	`377`	`firstLocalPoint,`
261	`378`	`firstLocalDisplacement,`
261	`379`	`secondOrigin,`
261	`380`	`secondRotation,`
261	`381`	`secondLocalPoint,`
261	`382`	`secondLocalDisplacement,`
261	`383`	`direction,`
261	`384`	`out Signed704 numerator,`
261	`385`	`out Signed704 denominator);`
261	`386`	`return Fixed64.TryGetSignedRawRatio(`
261	`387`	`numerator,`
261	`388`	`denominator,`
261	`389`	`out projection);`
	`390`	`}`
	`391`
	`392`	`internal static Fixed64 ProjectNonNegativeOffset(`
	`393`	`Vector3d firstOrigin,`
	`394`	`FixedQuaternion firstRotation,`
	`395`	`Vector3d firstLocalPoint,`
	`396`	`Vector3d firstLocalDisplacement,`
	`397`	`Vector3d secondOrigin,`
	`398`	`FixedQuaternion secondRotation,`
	`399`	`Vector3d secondLocalPoint,`
	`400`	`Vector3d secondLocalDisplacement,`
	`401`	`Vector3d direction)`
	`402`	`{`
259	`403`	`GetProjectedOffsetRatio(`
259	`404`	`firstOrigin,`
259	`405`	`firstRotation,`
259	`406`	`firstLocalPoint,`
259	`407`	`firstLocalDisplacement,`
259	`408`	`secondOrigin,`
259	`409`	`secondRotation,`
259	`410`	`secondLocalPoint,`
259	`411`	`secondLocalDisplacement,`
259	`412`	`direction,`
259	`413`	`out Signed704 numerator,`
259	`414`	`out Signed704 denominator);`
259	`415`	`return Fixed64.GetNonNegativeRawRatioFloor(`
259	`416`	`numerator,`
259	`417`	`denominator);`
	`418`	`}`
	`419`
	`420`	`internal static void GetProjectedOffsetRatio(`
	`421`	`in FixedPointAnchor first,`
	`422`	`in FixedPointAnchor second,`
	`423`	`Vector3d direction,`
	`424`	`out Signed704 numerator,`
	`425`	`out Signed704 denominator)`
	`426`	`{`
155	`427`	`if (!first.ExactLocalTerm.IsZero`
155	`428`	`\|\| first.LocalTranslation != Vector3d.Zero)`
	`429`	`{`
78	`430`	`GetExactProjectedOffsetRatio(`
78	`431`	`first.Origin,`
78	`432`	`first.Rotation,`
78	`433`	`first.LocalPoint,`
78	`434`	`first.LocalDisplacement,`
78	`435`	`first.LocalTranslation,`
78	`436`	`first.ExactLocalTerm,`
78	`437`	`second.Origin,`
78	`438`	`second.Rotation,`
78	`439`	`second.LocalPoint,`
78	`440`	`second.LocalDisplacement,`
78	`441`	`second.LocalTranslation,`
78	`442`	`second.ExactLocalTerm,`
78	`443`	`direction,`
78	`444`	`out numerator,`
78	`445`	`out denominator);`
78	`446`	`return;`
	`447`	`}`
	`448`
77	`449`	`GetProjectedOffsetRatio(`
77	`450`	`first.Origin,`
77	`451`	`first.Rotation,`
77	`452`	`first.LocalPoint,`
77	`453`	`first.LocalDisplacement,`
77	`454`	`second.Origin,`
77	`455`	`second.Rotation,`
77	`456`	`second.LocalPoint,`
77	`457`	`second.LocalDisplacement,`
77	`458`	`direction,`
77	`459`	`out numerator,`
77	`460`	`out denominator);`
77	`461`	`}`
	`462`
	`463`	`private static void GetProjectedOffsetRatio(`
	`464`	`Vector3d firstOrigin,`
	`465`	`FixedQuaternion firstRotation,`
	`466`	`Vector3d firstLocalPoint,`
	`467`	`Vector3d firstLocalDisplacement,`
	`468`	`Vector3d secondOrigin,`
	`469`	`FixedQuaternion secondRotation,`
	`470`	`Vector3d secondLocalPoint,`
	`471`	`Vector3d secondLocalDisplacement,`
	`472`	`Vector3d direction,`
	`473`	`out Signed704 numerator,`
	`474`	`out Signed704 denominator)`
	`475`	`{`
597	`476`	`WideRationalBasis3d firstBasis = new(firstRotation);`
597	`477`	`WideRationalBasis3d secondBasis = new(secondRotation);`
597	`478`	`Signed320 coordinateDenominator =`
597	`479`	`WideArithmetic.MultiplySigned192(`
597	`480`	`firstBasis.Denominator,`
597	`481`	`secondBasis.Denominator);`
597	`482`	`Signed576 coordinateDenominatorWide =`
597	`483`	`Signed576.ExtendValue(coordinateDenominator);`
597	`484`	`Signed576 x = GetRelativeOffsetNumerator(`
597	`485`	`firstOrigin.X,`
597	`486`	`firstBasis.Xx,`
597	`487`	`firstBasis.Yx,`
597	`488`	`firstBasis.Zx,`
597	`489`	`firstBasis.Denominator,`
597	`490`	`firstLocalPoint,`
597	`491`	`firstLocalDisplacement,`
597	`492`	`secondOrigin.X,`
597	`493`	`secondBasis.Xx,`
597	`494`	`secondBasis.Yx,`
597	`495`	`secondBasis.Zx,`
597	`496`	`secondBasis.Denominator,`
597	`497`	`secondLocalPoint,`
597	`498`	`secondLocalDisplacement,`
597	`499`	`coordinateDenominator);`
597	`500`	`Signed576 y = GetRelativeOffsetNumerator(`
597	`501`	`firstOrigin.Y,`
597	`502`	`firstBasis.Xy,`
597	`503`	`firstBasis.Yy,`
597	`504`	`firstBasis.Zy,`
597	`505`	`firstBasis.Denominator,`
597	`506`	`firstLocalPoint,`
597	`507`	`firstLocalDisplacement,`
597	`508`	`secondOrigin.Y,`
597	`509`	`secondBasis.Xy,`
597	`510`	`secondBasis.Yy,`
597	`511`	`secondBasis.Zy,`
597	`512`	`secondBasis.Denominator,`
597	`513`	`secondLocalPoint,`
597	`514`	`secondLocalDisplacement,`
597	`515`	`coordinateDenominator);`
597	`516`	`Signed576 z = GetRelativeOffsetNumerator(`
597	`517`	`firstOrigin.Z,`
597	`518`	`firstBasis.Xz,`
597	`519`	`firstBasis.Yz,`
597	`520`	`firstBasis.Zz,`
597	`521`	`firstBasis.Denominator,`
597	`522`	`firstLocalPoint,`
597	`523`	`firstLocalDisplacement,`
597	`524`	`secondOrigin.Z,`
597	`525`	`secondBasis.Xz,`
597	`526`	`secondBasis.Yz,`
597	`527`	`secondBasis.Zz,`
597	`528`	`secondBasis.Denominator,`
597	`529`	`secondLocalPoint,`
597	`530`	`secondLocalDisplacement,`
597	`531`	`coordinateDenominator);`
597	`532`	`numerator = WideArithmetic.AddSigned704(`
597	`533`	`WideArithmetic.AddSigned704(`
597	`534`	`WideArithmetic.MultiplySigned576ToSigned704(`
597	`535`	`x,`
597	`536`	`Signed320.ExtendValue(Signed192.Raw(direction.X))),`
597	`537`	`WideArithmetic.MultiplySigned576ToSigned704(`
597	`538`	`y,`
597	`539`	`Signed320.ExtendValue(Signed192.Raw(direction.Y)))),`
597	`540`	`WideArithmetic.MultiplySigned576ToSigned704(`
597	`541`	`z,`
597	`542`	`Signed320.ExtendValue(Signed192.Raw(direction.Z))));`
597	`543`	`denominator = WideArithmetic.MultiplySigned576ToSigned704(`
597	`544`	`coordinateDenominatorWide,`
597	`545`	`Signed320.ExtendValue(Signed192.One));`
597	`546`	`}`
	`547`
	`548`	`private static bool TryGetPointCoordinate(`
	`549`	`Fixed64 origin,`
	`550`	`Signed192 axisX,`
	`551`	`Signed192 axisY,`
	`552`	`Signed192 axisZ,`
	`553`	`Signed192 denominator,`
	`554`	`Signed576 denominatorWide,`
	`555`	`Vector3d localPoint,`
	`556`	`Vector3d localDisplacement,`
	`557`	`out Fixed64 coordinate)`
	`558`	`{`
1812	`559`	`Signed320 numerator = WideArithmetic.AddSigned320(`
1812	`560`	`WideArithmetic.MultiplySigned192(Signed192.Raw(origin), denominator),`
1812	`561`	`WideArithmetic.AddSigned320(`
1812	`562`	`WideArithmetic.GetDotProduct3D(`
1812	`563`	`Signed192.Raw(localPoint.X),`
1812	`564`	`Signed192.Raw(localPoint.Y),`
1812	`565`	`Signed192.Raw(localPoint.Z),`
1812	`566`	`axisX,`
1812	`567`	`axisY,`
1812	`568`	`axisZ),`
1812	`569`	`WideArithmetic.GetDotProduct3D(`
1812	`570`	`Signed192.Raw(localDisplacement.X),`
1812	`571`	`Signed192.Raw(localDisplacement.Y),`
1812	`572`	`Signed192.Raw(localDisplacement.Z),`
1812	`573`	`axisX,`
1812	`574`	`axisY,`
1812	`575`	`axisZ)));`
1812	`576`	`return Fixed64.TryGetSignedRawRatio(`
1812	`577`	`Signed576.ExtendValue(numerator),`
1812	`578`	`denominatorWide,`
1812	`579`	`out coordinate);`
	`580`	`}`
	`581`
	`582`	`private static bool TryGetRelativeOffsetCoordinate(`
	`583`	`Fixed64 firstOrigin,`
	`584`	`Signed192 firstAxisX,`
	`585`	`Signed192 firstAxisY,`
	`586`	`Signed192 firstAxisZ,`
	`587`	`Signed192 firstDenominator,`
	`588`	`Vector3d firstLocalPoint,`
	`589`	`Vector3d firstLocalDisplacement,`
	`590`	`Fixed64 secondOrigin,`
	`591`	`Signed192 secondAxisX,`
	`592`	`Signed192 secondAxisY,`
	`593`	`Signed192 secondAxisZ,`
	`594`	`Signed192 secondDenominator,`
	`595`	`Vector3d secondLocalPoint,`
	`596`	`Vector3d secondLocalDisplacement,`
	`597`	`Signed320 denominator,`
	`598`	`Signed576 denominatorWide,`
	`599`	`Fixed64 scale,`
	`600`	`out Fixed64 coordinate)`
	`601`	`{`
882	`602`	`Signed576 numerator = GetRelativeOffsetNumerator(`
882	`603`	`firstOrigin,`
882	`604`	`firstAxisX,`
882	`605`	`firstAxisY,`
882	`606`	`firstAxisZ,`
882	`607`	`firstDenominator,`
882	`608`	`firstLocalPoint,`
882	`609`	`firstLocalDisplacement,`
882	`610`	`secondOrigin,`
882	`611`	`secondAxisX,`
882	`612`	`secondAxisY,`
882	`613`	`secondAxisZ,`
882	`614`	`secondDenominator,`
882	`615`	`secondLocalPoint,`
882	`616`	`secondLocalDisplacement,`
882	`617`	`denominator);`
882	`618`	`if (scale == Fixed64.One)`
	`619`	`{`
105	`620`	`return Fixed64.TryGetSignedRawRatio(`
105	`621`	`numerator,`
105	`622`	`denominatorWide,`
105	`623`	`out coordinate);`
	`624`	`}`
777	`625`	`Signed320 scaleRaw = Signed320.ExtendValue(Signed192.Raw(scale));`
777	`626`	`Signed320 oneRaw = Signed320.ExtendValue(Signed192.One);`
777	`627`	`return Fixed64.TryGetSignedRawRatio(`
777	`628`	`WideArithmetic.MultiplySigned576ToSigned704(`
777	`629`	`numerator,`
777	`630`	`scaleRaw),`
777	`631`	`WideArithmetic.MultiplySigned576ToSigned704(`
777	`632`	`denominatorWide,`
777	`633`	`oneRaw),`
777	`634`	`out coordinate);`
	`635`	`}`
	`636`
	`637`	`private static Signed576 GetRelativeOffsetNumerator(`
	`638`	`Fixed64 firstOrigin,`
	`639`	`Signed192 firstAxisX,`
	`640`	`Signed192 firstAxisY,`
	`641`	`Signed192 firstAxisZ,`
	`642`	`Signed192 firstDenominator,`
	`643`	`Vector3d firstLocalPoint,`
	`644`	`Vector3d firstLocalDisplacement,`
	`645`	`Fixed64 secondOrigin,`
	`646`	`Signed192 secondAxisX,`
	`647`	`Signed192 secondAxisY,`
	`648`	`Signed192 secondAxisZ,`
	`649`	`Signed192 secondDenominator,`
	`650`	`Vector3d secondLocalPoint,`
	`651`	`Vector3d secondLocalDisplacement,`
	`652`	`Signed320 denominator)`
	`653`	`{`
3663	`654`	`Signed320 firstRotated = WideArithmetic.GetDotProduct3D(`
3663	`655`	`Signed192.Raw(firstLocalPoint.X),`
3663	`656`	`Signed192.Raw(firstLocalPoint.Y),`
3663	`657`	`Signed192.Raw(firstLocalPoint.Z),`
3663	`658`	`firstAxisX,`
3663	`659`	`firstAxisY,`
3663	`660`	`firstAxisZ);`
3663	`661`	`firstRotated = WideArithmetic.AddSigned320(`
3663	`662`	`firstRotated,`
3663	`663`	`WideArithmetic.GetDotProduct3D(`
3663	`664`	`Signed192.Raw(firstLocalDisplacement.X),`
3663	`665`	`Signed192.Raw(firstLocalDisplacement.Y),`
3663	`666`	`Signed192.Raw(firstLocalDisplacement.Z),`
3663	`667`	`firstAxisX,`
3663	`668`	`firstAxisY,`
3663	`669`	`firstAxisZ));`
3663	`670`	`Signed320 secondRotated = WideArithmetic.GetDotProduct3D(`
3663	`671`	`Signed192.Raw(secondLocalPoint.X),`
3663	`672`	`Signed192.Raw(secondLocalPoint.Y),`
3663	`673`	`Signed192.Raw(secondLocalPoint.Z),`
3663	`674`	`secondAxisX,`
3663	`675`	`secondAxisY,`
3663	`676`	`secondAxisZ);`
3663	`677`	`secondRotated = WideArithmetic.AddSigned320(`
3663	`678`	`secondRotated,`
3663	`679`	`WideArithmetic.GetDotProduct3D(`
3663	`680`	`Signed192.Raw(secondLocalDisplacement.X),`
3663	`681`	`Signed192.Raw(secondLocalDisplacement.Y),`
3663	`682`	`Signed192.Raw(secondLocalDisplacement.Z),`
3663	`683`	`secondAxisX,`
3663	`684`	`secondAxisY,`
3663	`685`	`secondAxisZ));`
3663	`686`	`return WideArithmetic.SubtractSigned576(`
3663	`687`	`WideArithmetic.AddSigned576(`
3663	`688`	`WideArithmetic.MultiplySigned320(`
3663	`689`	`Signed320.ExtendValue(`
3663	`690`	`WideArithmetic.SubtractSigned192(`
3663	`691`	`Signed192.Raw(firstOrigin),`
3663	`692`	`Signed192.Raw(secondOrigin))),`
3663	`693`	`denominator),`
3663	`694`	`WideArithmetic.MultiplySigned320(`
3663	`695`	`firstRotated,`
3663	`696`	`Signed320.ExtendValue(secondDenominator))),`
3663	`697`	`WideArithmetic.MultiplySigned320(`
3663	`698`	`secondRotated,`
3663	`699`	`Signed320.ExtendValue(firstDenominator)));`
	`700`	`}`
	`701`
	`702`	`private static bool TryGetLocalPointCoordinate(`
	`703`	`Signed192 originX,`
	`704`	`Signed192 originY,`
	`705`	`Signed192 originZ,`
	`706`	`Signed320 rotatedX,`
	`707`	`Signed320 rotatedY,`
	`708`	`Signed320 rotatedZ,`
	`709`	`Signed192 pointDenominator,`
	`710`	`Signed192 frameAxisX,`
	`711`	`Signed192 frameAxisY,`
	`712`	`Signed192 frameAxisZ,`
	`713`	`Signed576 denominator,`
	`714`	`out Fixed64 coordinate)`
	`715`	`{`
13425	`716`	`Signed320 originProjection = WideArithmetic.GetDotProduct3D(`
13425	`717`	`originX,`
13425	`718`	`originY,`
13425	`719`	`originZ,`
13425	`720`	`frameAxisX,`
13425	`721`	`frameAxisY,`
13425	`722`	`frameAxisZ);`
13425	`723`	`Signed576 rotatedProjection = WideArithmetic.AddSigned576(`
13425	`724`	`WideArithmetic.AddSigned576(`
13425	`725`	`WideArithmetic.MultiplySigned320(`
13425	`726`	`rotatedX,`
13425	`727`	`Signed320.ExtendValue(frameAxisX)),`
13425	`728`	`WideArithmetic.MultiplySigned320(`
13425	`729`	`rotatedY,`
13425	`730`	`Signed320.ExtendValue(frameAxisY))),`
13425	`731`	`WideArithmetic.MultiplySigned320(`
13425	`732`	`rotatedZ,`
13425	`733`	`Signed320.ExtendValue(frameAxisZ)));`
13425	`734`	`Signed576 numerator = WideArithmetic.AddSigned576(`
13425	`735`	`WideArithmetic.MultiplySigned320(`
13425	`736`	`originProjection,`
13425	`737`	`Signed320.ExtendValue(pointDenominator)),`
13425	`738`	`rotatedProjection);`
13425	`739`	`return Fixed64.TryGetSignedRawRatio(`
13425	`740`	`numerator,`
13425	`741`	`denominator,`
13425	`742`	`out coordinate);`
	`743`	`}`
	`744`	`}`

/home/runner/work/FixedMathSharp/FixedMathSharp/src/FixedMathSharp/Geometry/Anchors/Wide/WidePointAnchor3d.Distance.cs

#	Line	Line coverage
	`1`	`//=======================================================================`
	`2`	`// WidePointAnchor3d.Distance.cs`
	`3`	`//=======================================================================`
	`4`	`// MIT License, Copyright (c) 2024–present David Oravsky (mrdav30)`
	`5`	`// See LICENSE file in the project root for full license information.`
	`6`	`//=======================================================================`
	`7`
	`8`	`namespace FixedMathSharp.Geometry;`
	`9`
	`10`	`/// <content>`
	`11`	`/// Exact three-dimensional point-anchor distance operations.`
	`12`	`/// </content>`
	`13`	`internal static partial class WidePointAnchor3d`
	`14`	`{`
	`15`	`internal static Vector3d GetDirection(`
	`16`	`in FixedPointAnchor first,`
	`17`	`in FixedPointAnchor second)`
	`18`	`{`
7	`19`	`GetExactRelativeOffsetRatio(`
7	`20`	`first.Origin,`
7	`21`	`first.Rotation,`
7	`22`	`first.LocalPoint,`
7	`23`	`first.LocalDisplacement,`
7	`24`	`first.LocalTranslation,`
7	`25`	`first.ExactLocalTerm,`
7	`26`	`second.Origin,`
7	`27`	`second.Rotation,`
7	`28`	`second.LocalPoint,`
7	`29`	`second.LocalDisplacement,`
7	`30`	`second.LocalTranslation,`
7	`31`	`second.ExactLocalTerm,`
7	`32`	`out Signed576 x,`
7	`33`	`out Signed576 y,`
7	`34`	`out Signed576 z,`
7	`35`	`out _);`
7	`36`	`return WideNormalization.GetNormalized(x, y, z);`
	`37`	`}`
	`38`
	`39`	`internal static int CompareSquaredDistances(`
	`40`	`in FixedPointAnchor reference,`
	`41`	`in FixedPointAnchor first,`
	`42`	`in FixedPointAnchor second)`
	`43`	`{`
176	`44`	`if (!reference.ExactLocalTerm.IsZero`
176	`45`	`\|\| !first.ExactLocalTerm.IsZero`
176	`46`	`\|\| !second.ExactLocalTerm.IsZero`
176	`47`	`\|\| reference.LocalTranslation != Vector3d.Zero`
176	`48`	`\|\| first.LocalTranslation != Vector3d.Zero`
176	`49`	`\|\| second.LocalTranslation != Vector3d.Zero)`
	`50`	`{`
11	`51`	`return CompareExactSquaredDistances(`
11	`52`	`reference,`
11	`53`	`first,`
11	`54`	`second);`
	`55`	`}`
	`56`
165	`57`	`GetSquaredOffsetRatio(`
165	`58`	`first,`
165	`59`	`reference,`
165	`60`	`out Signed832 firstNumerator,`
165	`61`	`out Signed576 firstDenominator);`
165	`62`	`GetSquaredOffsetRatio(`
165	`63`	`second,`
165	`64`	`reference,`
165	`65`	`out Signed832 secondNumerator,`
165	`66`	`out Signed576 secondDenominator);`
165	`67`	`return WideArithmetic.CompareNonNegativeSquaredRatios(`
165	`68`	`firstNumerator,`
165	`69`	`firstDenominator,`
165	`70`	`secondNumerator,`
165	`71`	`secondDenominator);`
	`72`	`}`
	`73`
	`74`	`private static int CompareExactSquaredDistances(`
	`75`	`in FixedPointAnchor reference,`
	`76`	`in FixedPointAnchor first,`
	`77`	`in FixedPointAnchor second)`
	`78`	`{`
11	`79`	`GetExactSquaredOffsetRatio(`
11	`80`	`first,`
11	`81`	`reference,`
11	`82`	`out Signed832 firstNumerator,`
11	`83`	`out Signed576 firstDenominator);`
11	`84`	`GetExactSquaredOffsetRatio(`
11	`85`	`second,`
11	`86`	`reference,`
11	`87`	`out Signed832 secondNumerator,`
11	`88`	`out Signed576 secondDenominator);`
11	`89`	`return WideArithmetic.CompareNonNegativeSquaredRatios(`
11	`90`	`firstNumerator,`
11	`91`	`firstDenominator,`
11	`92`	`secondNumerator,`
11	`93`	`secondDenominator);`
	`94`	`}`
	`95`
	`96`	`private static void GetExactSquaredOffsetRatio(`
	`97`	`in FixedPointAnchor first,`
	`98`	`in FixedPointAnchor second,`
	`99`	`out Signed832 squaredNumerator,`
	`100`	`out Signed576 denominator)`
	`101`	`{`
22	`102`	`GetExactRelativeOffsetRatio(`
22	`103`	`first.Origin,`
22	`104`	`first.Rotation,`
22	`105`	`first.LocalPoint,`
22	`106`	`first.LocalDisplacement,`
22	`107`	`first.LocalTranslation,`
22	`108`	`first.ExactLocalTerm,`
22	`109`	`second.Origin,`
22	`110`	`second.Rotation,`
22	`111`	`second.LocalPoint,`
22	`112`	`second.LocalDisplacement,`
22	`113`	`second.LocalTranslation,`
22	`114`	`second.ExactLocalTerm,`
22	`115`	`out Signed576 x,`
22	`116`	`out Signed576 y,`
22	`117`	`out Signed576 z,`
22	`118`	`out denominator);`
22	`119`	`squaredNumerator = WideArithmetic.AddSigned832(`
22	`120`	`WideArithmetic.AddSigned832(`
22	`121`	`WideArithmetic.MultiplySigned576ToSigned832(x, x),`
22	`122`	`WideArithmetic.MultiplySigned576ToSigned832(y, y)),`
22	`123`	`WideArithmetic.MultiplySigned576ToSigned832(z, z));`
22	`124`	`}`
	`125`
	`126`	`private static void GetSquaredOffsetRatio(`
	`127`	`in FixedPointAnchor first,`
	`128`	`in FixedPointAnchor second,`
	`129`	`out Signed832 squaredNumerator,`
	`130`	`out Signed576 denominator)`
	`131`	`{`
330	`132`	`WideRationalBasis3d firstBasis = new(first.Rotation);`
330	`133`	`WideRationalBasis3d secondBasis = new(second.Rotation);`
330	`134`	`Signed320 coordinateDenominator =`
330	`135`	`WideArithmetic.MultiplySigned192(`
330	`136`	`firstBasis.Denominator,`
330	`137`	`secondBasis.Denominator);`
330	`138`	`Signed576 x = GetRelativeOffsetNumerator(`
330	`139`	`first.Origin.X,`
330	`140`	`firstBasis.Xx,`
330	`141`	`firstBasis.Yx,`
330	`142`	`firstBasis.Zx,`
330	`143`	`firstBasis.Denominator,`
330	`144`	`first.LocalPoint,`
330	`145`	`first.LocalDisplacement,`
330	`146`	`second.Origin.X,`
330	`147`	`secondBasis.Xx,`
330	`148`	`secondBasis.Yx,`
330	`149`	`secondBasis.Zx,`
330	`150`	`secondBasis.Denominator,`
330	`151`	`second.LocalPoint,`
330	`152`	`second.LocalDisplacement,`
330	`153`	`coordinateDenominator);`
330	`154`	`Signed576 y = GetRelativeOffsetNumerator(`
330	`155`	`first.Origin.Y,`
330	`156`	`firstBasis.Xy,`
330	`157`	`firstBasis.Yy,`
330	`158`	`firstBasis.Zy,`
330	`159`	`firstBasis.Denominator,`
330	`160`	`first.LocalPoint,`
330	`161`	`first.LocalDisplacement,`
330	`162`	`second.Origin.Y,`
330	`163`	`secondBasis.Xy,`
330	`164`	`secondBasis.Yy,`
330	`165`	`secondBasis.Zy,`
330	`166`	`secondBasis.Denominator,`
330	`167`	`second.LocalPoint,`
330	`168`	`second.LocalDisplacement,`
330	`169`	`coordinateDenominator);`
330	`170`	`Signed576 z = GetRelativeOffsetNumerator(`
330	`171`	`first.Origin.Z,`
330	`172`	`firstBasis.Xz,`
330	`173`	`firstBasis.Yz,`
330	`174`	`firstBasis.Zz,`
330	`175`	`firstBasis.Denominator,`
330	`176`	`first.LocalPoint,`
330	`177`	`first.LocalDisplacement,`
330	`178`	`second.Origin.Z,`
330	`179`	`secondBasis.Xz,`
330	`180`	`secondBasis.Yz,`
330	`181`	`secondBasis.Zz,`
330	`182`	`secondBasis.Denominator,`
330	`183`	`second.LocalPoint,`
330	`184`	`second.LocalDisplacement,`
330	`185`	`coordinateDenominator);`
330	`186`	`squaredNumerator = WideArithmetic.AddSigned832(`
330	`187`	`WideArithmetic.AddSigned832(`
330	`188`	`WideArithmetic.MultiplySigned576ToSigned832(x, x),`
330	`189`	`WideArithmetic.MultiplySigned576ToSigned832(y, y)),`
330	`190`	`WideArithmetic.MultiplySigned576ToSigned832(z, z));`
330	`191`	`denominator = Signed576.ExtendValue(`
330	`192`	`coordinateDenominator);`
330	`193`	`}`
	`194`	`}`

/home/runner/work/FixedMathSharp/FixedMathSharp/src/FixedMathSharp/Geometry/Anchors/Wide/WidePointAnchor3d.Exact.cs

#	Line	Line coverage
	`1`	`//=======================================================================`
	`2`	`// WidePointAnchor3d.Exact.cs`
	`3`	`//=======================================================================`
	`4`	`// MIT License, Copyright (c) 2024–present David Oravsky (mrdav30)`
	`5`	`// See LICENSE file in the project root for full license information.`
	`6`	`//=======================================================================`
	`7`
	`8`	`namespace FixedMathSharp.Geometry;`
	`9`
	`10`	`/// <content>`
	`11`	`/// Exact three-dimensional point-anchor term operations.`
	`12`	`/// </content>`
	`13`	`internal static partial class WidePointAnchor3d`
	`14`	`{`
	`15`	`internal static bool TryGetPoint(`
	`16`	`Vector3d origin,`
	`17`	`FixedQuaternion rotation,`
	`18`	`Vector3d localPoint,`
	`19`	`Vector3d localDisplacement,`
	`20`	`Vector3d localTranslation,`
	`21`	`FixedPointAnchorTerm3d exactLocalTerm,`
	`22`	`out Vector3d point)`
	`23`	`{`
617	`24`	`if (exactLocalTerm.IsZero`
617	`25`	`&& localTranslation == Vector3d.Zero)`
	`26`	`{`
604	`27`	`return TryGetPoint(`
604	`28`	`origin,`
604	`29`	`rotation,`
604	`30`	`localPoint,`
604	`31`	`localDisplacement,`
604	`32`	`out point);`
	`33`	`}`
	`34`
13	`35`	`WideRationalBasis3d basis = new(rotation);`
13	`36`	`Signed320 denominator = GetAnchorDenominator(basis);`
13	`37`	`Signed576 denominatorWide =`
13	`38`	`Signed576.ExtendValue(denominator);`
13	`39`	`bool representable = Fixed64.TryGetSignedRawRatio(`
13	`40`	`Signed576.ExtendValue(`
13	`41`	`GetAnchorCoordinateNumerator(`
13	`42`	`origin.X,`
13	`43`	`basis.Xx,`
13	`44`	`basis.Yx,`
13	`45`	`basis.Zx,`
13	`46`	`basis,`
13	`47`	`localPoint,`
13	`48`	`localDisplacement,`
13	`49`	`localTranslation,`
13	`50`	`exactLocalTerm)),`
13	`51`	`denominatorWide,`
13	`52`	`out Fixed64 x)`
13	`53`	`& Fixed64.TryGetSignedRawRatio(`
13	`54`	`Signed576.ExtendValue(`
13	`55`	`GetAnchorCoordinateNumerator(`
13	`56`	`origin.Y,`
13	`57`	`basis.Xy,`
13	`58`	`basis.Yy,`
13	`59`	`basis.Zy,`
13	`60`	`basis,`
13	`61`	`localPoint,`
13	`62`	`localDisplacement,`
13	`63`	`localTranslation,`
13	`64`	`exactLocalTerm)),`
13	`65`	`denominatorWide,`
13	`66`	`out Fixed64 y)`
13	`67`	`& Fixed64.TryGetSignedRawRatio(`
13	`68`	`Signed576.ExtendValue(`
13	`69`	`GetAnchorCoordinateNumerator(`
13	`70`	`origin.Z,`
13	`71`	`basis.Xz,`
13	`72`	`basis.Yz,`
13	`73`	`basis.Zz,`
13	`74`	`basis,`
13	`75`	`localPoint,`
13	`76`	`localDisplacement,`
13	`77`	`localTranslation,`
13	`78`	`exactLocalTerm)),`
13	`79`	`denominatorWide,`
13	`80`	`out Fixed64 z);`
13	`81`	`point = representable ? new Vector3d(x, y, z) : default;`
13	`82`	`return representable;`
	`83`	`}`
	`84`
	`85`	`internal static bool TryGetRelativeOffset(`
	`86`	`Vector3d firstOrigin,`
	`87`	`FixedQuaternion firstRotation,`
	`88`	`Vector3d firstLocalPoint,`
	`89`	`Vector3d firstLocalDisplacement,`
	`90`	`Vector3d firstLocalTranslation,`
	`91`	`FixedPointAnchorTerm3d firstExactLocalTerm,`
	`92`	`Vector3d secondOrigin,`
	`93`	`FixedQuaternion secondRotation,`
	`94`	`Vector3d secondLocalPoint,`
	`95`	`Vector3d secondLocalDisplacement,`
	`96`	`Vector3d secondLocalTranslation,`
	`97`	`FixedPointAnchorTerm3d secondExactLocalTerm,`
	`98`	`Fixed64 scale,`
	`99`	`out Vector3d offset)`
	`100`	`{`
1420	`101`	`if (firstExactLocalTerm.IsZero`
1420	`102`	`&& secondExactLocalTerm.IsZero`
1420	`103`	`&& firstLocalTranslation == Vector3d.Zero`
1420	`104`	`&& secondLocalTranslation == Vector3d.Zero)`
	`105`	`{`
1396	`106`	`return TryGetRelativeOffset(`
1396	`107`	`firstOrigin,`
1396	`108`	`firstRotation,`
1396	`109`	`firstLocalPoint,`
1396	`110`	`firstLocalDisplacement,`
1396	`111`	`secondOrigin,`
1396	`112`	`secondRotation,`
1396	`113`	`secondLocalPoint,`
1396	`114`	`secondLocalDisplacement,`
1396	`115`	`scale,`
1396	`116`	`out offset);`
	`117`	`}`
	`118`
24	`119`	`GetExactRelativeOffsetRatio(`
24	`120`	`firstOrigin,`
24	`121`	`firstRotation,`
24	`122`	`firstLocalPoint,`
24	`123`	`firstLocalDisplacement,`
24	`124`	`firstLocalTranslation,`
24	`125`	`firstExactLocalTerm,`
24	`126`	`secondOrigin,`
24	`127`	`secondRotation,`
24	`128`	`secondLocalPoint,`
24	`129`	`secondLocalDisplacement,`
24	`130`	`secondLocalTranslation,`
24	`131`	`secondExactLocalTerm,`
24	`132`	`out Signed576 xNumerator,`
24	`133`	`out Signed576 yNumerator,`
24	`134`	`out Signed576 zNumerator,`
24	`135`	`out Signed576 denominator);`
24	`136`	`bool representable = TryGetScaledExactCoordinate(`
24	`137`	`xNumerator,`
24	`138`	`denominator,`
24	`139`	`scale,`
24	`140`	`out Fixed64 x)`
24	`141`	`& TryGetScaledExactCoordinate(`
24	`142`	`yNumerator,`
24	`143`	`denominator,`
24	`144`	`scale,`
24	`145`	`out Fixed64 y)`
24	`146`	`& TryGetScaledExactCoordinate(`
24	`147`	`zNumerator,`
24	`148`	`denominator,`
24	`149`	`scale,`
24	`150`	`out Fixed64 z);`
24	`151`	`offset = representable ? new Vector3d(x, y, z) : default;`
24	`152`	`return representable;`
	`153`	`}`
	`154`
	`155`	`internal static bool RepresentsSamePoint(`
	`156`	`in FixedPointAnchor first,`
	`157`	`in FixedPointAnchor second)`
	`158`	`{`
3	`159`	`GetExactRelativeOffsetRatio(`
3	`160`	`first.Origin,`
3	`161`	`first.Rotation,`
3	`162`	`first.LocalPoint,`
3	`163`	`first.LocalDisplacement,`
3	`164`	`first.LocalTranslation,`
3	`165`	`first.ExactLocalTerm,`
3	`166`	`second.Origin,`
3	`167`	`second.Rotation,`
3	`168`	`second.LocalPoint,`
3	`169`	`second.LocalDisplacement,`
3	`170`	`second.LocalTranslation,`
3	`171`	`second.ExactLocalTerm,`
3	`172`	`out Signed576 x,`
3	`173`	`out Signed576 y,`
3	`174`	`out Signed576 z,`
3	`175`	`out _);`
3	`176`	`return x.IsZero && y.IsZero && z.IsZero;`
	`177`	`}`
	`178`
	`179`	`internal static bool TryGetLocalPointIn(`
	`180`	`Vector3d pointOrigin,`
	`181`	`FixedQuaternion pointRotation,`
	`182`	`Vector3d pointLocalPoint,`
	`183`	`Vector3d pointLocalDisplacement,`
	`184`	`Vector3d pointLocalTranslation,`
	`185`	`FixedPointAnchorTerm3d exactLocalTerm,`
	`186`	`Vector3d frameOrigin,`
	`187`	`FixedQuaternion frameRotation,`
	`188`	`out Vector3d localPoint)`
	`189`	`{`
4539	`190`	`if (exactLocalTerm.IsZero`
4539	`191`	`&& pointLocalTranslation == Vector3d.Zero)`
	`192`	`{`
4475	`193`	`return TryGetLocalPointIn(`
4475	`194`	`pointOrigin,`
4475	`195`	`pointRotation,`
4475	`196`	`pointLocalPoint,`
4475	`197`	`pointLocalDisplacement,`
4475	`198`	`frameOrigin,`
4475	`199`	`frameRotation,`
4475	`200`	`out localPoint);`
	`201`	`}`
	`202`
64	`203`	`WideRationalBasis3d pointBasis = new(pointRotation);`
64	`204`	`WideRationalBasis3d frameBasis = new(frameRotation);`
64	`205`	`Signed320 pointDenominator = GetAnchorDenominator(pointBasis);`
64	`206`	`Signed320 deltaX = GetAnchorDeltaNumerator(`
64	`207`	`pointOrigin.X,`
64	`208`	`frameOrigin.X,`
64	`209`	`pointBasis.Xx,`
64	`210`	`pointBasis.Yx,`
64	`211`	`pointBasis.Zx,`
64	`212`	`pointBasis,`
64	`213`	`pointLocalPoint,`
64	`214`	`pointLocalDisplacement,`
64	`215`	`pointLocalTranslation,`
64	`216`	`exactLocalTerm,`
64	`217`	`pointDenominator);`
64	`218`	`Signed320 deltaY = GetAnchorDeltaNumerator(`
64	`219`	`pointOrigin.Y,`
64	`220`	`frameOrigin.Y,`
64	`221`	`pointBasis.Xy,`
64	`222`	`pointBasis.Yy,`
64	`223`	`pointBasis.Zy,`
64	`224`	`pointBasis,`
64	`225`	`pointLocalPoint,`
64	`226`	`pointLocalDisplacement,`
64	`227`	`pointLocalTranslation,`
64	`228`	`exactLocalTerm,`
64	`229`	`pointDenominator);`
64	`230`	`Signed320 deltaZ = GetAnchorDeltaNumerator(`
64	`231`	`pointOrigin.Z,`
64	`232`	`frameOrigin.Z,`
64	`233`	`pointBasis.Xz,`
64	`234`	`pointBasis.Yz,`
64	`235`	`pointBasis.Zz,`
64	`236`	`pointBasis,`
64	`237`	`pointLocalPoint,`
64	`238`	`pointLocalDisplacement,`
64	`239`	`pointLocalTranslation,`
64	`240`	`exactLocalTerm,`
64	`241`	`pointDenominator);`
64	`242`	`Signed576 denominator = WideArithmetic.MultiplySigned320(`
64	`243`	`pointDenominator,`
64	`244`	`Signed320.ExtendValue(frameBasis.Denominator));`
64	`245`	`bool representable = Fixed64.TryGetSignedRawRatio(`
64	`246`	`GetWideProjection(`
64	`247`	`deltaX,`
64	`248`	`deltaY,`
64	`249`	`deltaZ,`
64	`250`	`frameBasis.Xx,`
64	`251`	`frameBasis.Xy,`
64	`252`	`frameBasis.Xz),`
64	`253`	`denominator,`
64	`254`	`out Fixed64 x)`
64	`255`	`& Fixed64.TryGetSignedRawRatio(`
64	`256`	`GetWideProjection(`
64	`257`	`deltaX,`
64	`258`	`deltaY,`
64	`259`	`deltaZ,`
64	`260`	`frameBasis.Yx,`
64	`261`	`frameBasis.Yy,`
64	`262`	`frameBasis.Yz),`
64	`263`	`denominator,`
64	`264`	`out Fixed64 y)`
64	`265`	`& Fixed64.TryGetSignedRawRatio(`
64	`266`	`GetWideProjection(`
64	`267`	`deltaX,`
64	`268`	`deltaY,`
64	`269`	`deltaZ,`
64	`270`	`frameBasis.Zx,`
64	`271`	`frameBasis.Zy,`
64	`272`	`frameBasis.Zz),`
64	`273`	`denominator,`
64	`274`	`out Fixed64 z);`
64	`275`	`localPoint = representable ? new Vector3d(x, y, z) : default;`
64	`276`	`return representable;`
	`277`	`}`
	`278`
	`279`	`internal static bool TryGetProjectedOffset(`
	`280`	`Vector3d firstOrigin,`
	`281`	`FixedQuaternion firstRotation,`
	`282`	`Vector3d firstLocalPoint,`
	`283`	`Vector3d firstLocalDisplacement,`
	`284`	`Vector3d firstLocalTranslation,`
	`285`	`FixedPointAnchorTerm3d firstExactLocalTerm,`
	`286`	`Vector3d secondOrigin,`
	`287`	`FixedQuaternion secondRotation,`
	`288`	`Vector3d secondLocalPoint,`
	`289`	`Vector3d secondLocalDisplacement,`
	`290`	`Vector3d secondLocalTranslation,`
	`291`	`FixedPointAnchorTerm3d secondExactLocalTerm,`
	`292`	`Vector3d direction,`
	`293`	`out Fixed64 projection)`
	`294`	`{`
277	`295`	`if (firstExactLocalTerm.IsZero`
277	`296`	`&& secondExactLocalTerm.IsZero`
277	`297`	`&& firstLocalTranslation == Vector3d.Zero`
277	`298`	`&& secondLocalTranslation == Vector3d.Zero)`
	`299`	`{`
261	`300`	`return TryGetProjectedOffset(`
261	`301`	`firstOrigin,`
261	`302`	`firstRotation,`
261	`303`	`firstLocalPoint,`
261	`304`	`firstLocalDisplacement,`
261	`305`	`secondOrigin,`
261	`306`	`secondRotation,`
261	`307`	`secondLocalPoint,`
261	`308`	`secondLocalDisplacement,`
261	`309`	`direction,`
261	`310`	`out projection);`
	`311`	`}`
	`312`
16	`313`	`GetExactProjectedOffsetRatio(`
16	`314`	`firstOrigin,`
16	`315`	`firstRotation,`
16	`316`	`firstLocalPoint,`
16	`317`	`firstLocalDisplacement,`
16	`318`	`firstLocalTranslation,`
16	`319`	`firstExactLocalTerm,`
16	`320`	`secondOrigin,`
16	`321`	`secondRotation,`
16	`322`	`secondLocalPoint,`
16	`323`	`secondLocalDisplacement,`
16	`324`	`secondLocalTranslation,`
16	`325`	`secondExactLocalTerm,`
16	`326`	`direction,`
16	`327`	`out Signed704 numerator,`
16	`328`	`out Signed704 denominator);`
16	`329`	`return Fixed64.TryGetSignedRawRatio(`
16	`330`	`numerator,`
16	`331`	`denominator,`
16	`332`	`out projection);`
	`333`	`}`
	`334`
	`335`	`internal static Fixed64 ProjectNonNegativeOffset(`
	`336`	`Vector3d firstOrigin,`
	`337`	`FixedQuaternion firstRotation,`
	`338`	`Vector3d firstLocalPoint,`
	`339`	`Vector3d firstLocalDisplacement,`
	`340`	`Vector3d firstLocalTranslation,`
	`341`	`FixedPointAnchorTerm3d firstExactLocalTerm,`
	`342`	`Vector3d secondOrigin,`
	`343`	`FixedQuaternion secondRotation,`
	`344`	`Vector3d secondLocalPoint,`
	`345`	`Vector3d secondLocalDisplacement,`
	`346`	`Vector3d secondLocalTranslation,`
	`347`	`FixedPointAnchorTerm3d secondExactLocalTerm,`
	`348`	`Vector3d direction)`
	`349`	`{`
262	`350`	`if (firstExactLocalTerm.IsZero`
262	`351`	`&& secondExactLocalTerm.IsZero`
262	`352`	`&& firstLocalTranslation == Vector3d.Zero`
262	`353`	`&& secondLocalTranslation == Vector3d.Zero)`
	`354`	`{`
259	`355`	`return ProjectNonNegativeOffset(`
259	`356`	`firstOrigin,`
259	`357`	`firstRotation,`
259	`358`	`firstLocalPoint,`
259	`359`	`firstLocalDisplacement,`
259	`360`	`secondOrigin,`
259	`361`	`secondRotation,`
259	`362`	`secondLocalPoint,`
259	`363`	`secondLocalDisplacement,`
259	`364`	`direction);`
	`365`	`}`
	`366`
3	`367`	`GetExactProjectedOffsetRatio(`
3	`368`	`firstOrigin,`
3	`369`	`firstRotation,`
3	`370`	`firstLocalPoint,`
3	`371`	`firstLocalDisplacement,`
3	`372`	`firstLocalTranslation,`
3	`373`	`firstExactLocalTerm,`
3	`374`	`secondOrigin,`
3	`375`	`secondRotation,`
3	`376`	`secondLocalPoint,`
3	`377`	`secondLocalDisplacement,`
3	`378`	`secondLocalTranslation,`
3	`379`	`secondExactLocalTerm,`
3	`380`	`direction,`
3	`381`	`out Signed704 numerator,`
3	`382`	`out Signed704 denominator);`
3	`383`	`return Fixed64.GetNonNegativeRawRatioFloor(`
3	`384`	`numerator,`
3	`385`	`denominator);`
	`386`	`}`
	`387`
	`388`	`private static void GetExactProjectedOffsetRatio(`
	`389`	`Vector3d firstOrigin,`
	`390`	`FixedQuaternion firstRotation,`
	`391`	`Vector3d firstLocalPoint,`
	`392`	`Vector3d firstLocalDisplacement,`
	`393`	`Vector3d firstLocalTranslation,`
	`394`	`FixedPointAnchorTerm3d firstExactLocalTerm,`
	`395`	`Vector3d secondOrigin,`
	`396`	`FixedQuaternion secondRotation,`
	`397`	`Vector3d secondLocalPoint,`
	`398`	`Vector3d secondLocalDisplacement,`
	`399`	`Vector3d secondLocalTranslation,`
	`400`	`FixedPointAnchorTerm3d secondExactLocalTerm,`
	`401`	`Vector3d direction,`
	`402`	`out Signed704 numerator,`
	`403`	`out Signed704 denominator)`
	`404`	`{`
97	`405`	`GetExactRelativeOffsetRatio(`
97	`406`	`firstOrigin,`
97	`407`	`firstRotation,`
97	`408`	`firstLocalPoint,`
97	`409`	`firstLocalDisplacement,`
97	`410`	`firstLocalTranslation,`
97	`411`	`firstExactLocalTerm,`
97	`412`	`secondOrigin,`
97	`413`	`secondRotation,`
97	`414`	`secondLocalPoint,`
97	`415`	`secondLocalDisplacement,`
97	`416`	`secondLocalTranslation,`
97	`417`	`secondExactLocalTerm,`
97	`418`	`out Signed576 x,`
97	`419`	`out Signed576 y,`
97	`420`	`out Signed576 z,`
97	`421`	`out Signed576 coordinateDenominator);`
97	`422`	`numerator = WideArithmetic.AddSigned704(`
97	`423`	`WideArithmetic.AddSigned704(`
97	`424`	`WideArithmetic.MultiplySigned576ToSigned704(`
97	`425`	`x,`
97	`426`	`Signed320.ExtendValue(Signed192.Raw(direction.X))),`
97	`427`	`WideArithmetic.MultiplySigned576ToSigned704(`
97	`428`	`y,`
97	`429`	`Signed320.ExtendValue(Signed192.Raw(direction.Y)))),`
97	`430`	`WideArithmetic.MultiplySigned576ToSigned704(`
97	`431`	`z,`
97	`432`	`Signed320.ExtendValue(Signed192.Raw(direction.Z))));`
97	`433`	`denominator = WideArithmetic.MultiplySigned576ToSigned704(`
97	`434`	`coordinateDenominator,`
97	`435`	`Signed320.ExtendValue(Signed192.One));`
97	`436`	`}`
	`437`
	`438`	`internal static void GetExactRelativeOffsetRatio(`
	`439`	`Vector3d firstOrigin,`
	`440`	`FixedQuaternion firstRotation,`
	`441`	`Vector3d firstLocalPoint,`
	`442`	`Vector3d firstLocalDisplacement,`
	`443`	`Vector3d firstLocalTranslation,`
	`444`	`FixedPointAnchorTerm3d firstExactLocalTerm,`
	`445`	`Vector3d secondOrigin,`
	`446`	`FixedQuaternion secondRotation,`
	`447`	`Vector3d secondLocalPoint,`
	`448`	`Vector3d secondLocalDisplacement,`
	`449`	`Vector3d secondLocalTranslation,`
	`450`	`FixedPointAnchorTerm3d secondExactLocalTerm,`
	`451`	`out Signed576 x,`
	`452`	`out Signed576 y,`
	`453`	`out Signed576 z,`
	`454`	`out Signed576 denominator)`
	`455`	`{`
153	`456`	`WideRationalBasis3d firstBasis = new(firstRotation);`
153	`457`	`WideRationalBasis3d secondBasis = new(secondRotation);`
153	`458`	`Signed320 firstDenominator = GetAnchorDenominator(firstBasis);`
153	`459`	`Signed320 secondDenominator = GetAnchorDenominator(secondBasis);`
153	`460`	`denominator = WideArithmetic.MultiplySigned320(`
153	`461`	`firstDenominator,`
153	`462`	`secondDenominator);`
153	`463`	`x = GetExactRelativeOffsetNumerator(`
153	`464`	`firstOrigin.X,`
153	`465`	`firstBasis.Xx,`
153	`466`	`firstBasis.Yx,`
153	`467`	`firstBasis.Zx,`
153	`468`	`firstBasis,`
153	`469`	`firstLocalPoint,`
153	`470`	`firstLocalDisplacement,`
153	`471`	`firstLocalTranslation,`
153	`472`	`firstExactLocalTerm,`
153	`473`	`firstDenominator,`
153	`474`	`secondOrigin.X,`
153	`475`	`secondBasis.Xx,`
153	`476`	`secondBasis.Yx,`
153	`477`	`secondBasis.Zx,`
153	`478`	`secondBasis,`
153	`479`	`secondLocalPoint,`
153	`480`	`secondLocalDisplacement,`
153	`481`	`secondLocalTranslation,`
153	`482`	`secondExactLocalTerm,`
153	`483`	`secondDenominator);`
153	`484`	`y = GetExactRelativeOffsetNumerator(`
153	`485`	`firstOrigin.Y,`
153	`486`	`firstBasis.Xy,`
153	`487`	`firstBasis.Yy,`
153	`488`	`firstBasis.Zy,`
153	`489`	`firstBasis,`
153	`490`	`firstLocalPoint,`
153	`491`	`firstLocalDisplacement,`
153	`492`	`firstLocalTranslation,`
153	`493`	`firstExactLocalTerm,`
153	`494`	`firstDenominator,`
153	`495`	`secondOrigin.Y,`
153	`496`	`secondBasis.Xy,`
153	`497`	`secondBasis.Yy,`
153	`498`	`secondBasis.Zy,`
153	`499`	`secondBasis,`
153	`500`	`secondLocalPoint,`
153	`501`	`secondLocalDisplacement,`
153	`502`	`secondLocalTranslation,`
153	`503`	`secondExactLocalTerm,`
153	`504`	`secondDenominator);`
153	`505`	`z = GetExactRelativeOffsetNumerator(`
153	`506`	`firstOrigin.Z,`
153	`507`	`firstBasis.Xz,`
153	`508`	`firstBasis.Yz,`
153	`509`	`firstBasis.Zz,`
153	`510`	`firstBasis,`
153	`511`	`firstLocalPoint,`
153	`512`	`firstLocalDisplacement,`
153	`513`	`firstLocalTranslation,`
153	`514`	`firstExactLocalTerm,`
153	`515`	`firstDenominator,`
153	`516`	`secondOrigin.Z,`
153	`517`	`secondBasis.Xz,`
153	`518`	`secondBasis.Yz,`
153	`519`	`secondBasis.Zz,`
153	`520`	`secondBasis,`
153	`521`	`secondLocalPoint,`
153	`522`	`secondLocalDisplacement,`
153	`523`	`secondLocalTranslation,`
153	`524`	`secondExactLocalTerm,`
153	`525`	`secondDenominator);`
153	`526`	`}`
	`527`
	`528`	`private static Signed576 GetExactRelativeOffsetNumerator(`
	`529`	`Fixed64 firstOrigin,`
	`530`	`Signed192 firstAxisX,`
	`531`	`Signed192 firstAxisY,`
	`532`	`Signed192 firstAxisZ,`
	`533`	`WideRationalBasis3d firstBasis,`
	`534`	`Vector3d firstLocalPoint,`
	`535`	`Vector3d firstLocalDisplacement,`
	`536`	`Vector3d firstLocalTranslation,`
	`537`	`FixedPointAnchorTerm3d firstExactLocalTerm,`
	`538`	`Signed320 firstDenominator,`
	`539`	`Fixed64 secondOrigin,`
	`540`	`Signed192 secondAxisX,`
	`541`	`Signed192 secondAxisY,`
	`542`	`Signed192 secondAxisZ,`
	`543`	`WideRationalBasis3d secondBasis,`
	`544`	`Vector3d secondLocalPoint,`
	`545`	`Vector3d secondLocalDisplacement,`
	`546`	`Vector3d secondLocalTranslation,`
	`547`	`FixedPointAnchorTerm3d secondExactLocalTerm,`
	`548`	`Signed320 secondDenominator) =>`
459	`549`	`WideArithmetic.SubtractSigned576(`
459	`550`	`WideArithmetic.MultiplySigned320(`
459	`551`	`GetAnchorCoordinateNumerator(`
459	`552`	`firstOrigin,`
459	`553`	`firstAxisX,`
459	`554`	`firstAxisY,`
459	`555`	`firstAxisZ,`
459	`556`	`firstBasis,`
459	`557`	`firstLocalPoint,`
459	`558`	`firstLocalDisplacement,`
459	`559`	`firstLocalTranslation,`
459	`560`	`firstExactLocalTerm),`
459	`561`	`secondDenominator),`
459	`562`	`WideArithmetic.MultiplySigned320(`
459	`563`	`GetAnchorCoordinateNumerator(`
459	`564`	`secondOrigin,`
459	`565`	`secondAxisX,`
459	`566`	`secondAxisY,`
459	`567`	`secondAxisZ,`
459	`568`	`secondBasis,`
459	`569`	`secondLocalPoint,`
459	`570`	`secondLocalDisplacement,`
459	`571`	`secondLocalTranslation,`
459	`572`	`secondExactLocalTerm),`
459	`573`	`firstDenominator));`
	`574`
	`575`	`private static Signed320 GetAnchorCoordinateNumerator(`
	`576`	`Fixed64 origin,`
	`577`	`Signed192 axisX,`
	`578`	`Signed192 axisY,`
	`579`	`Signed192 axisZ,`
	`580`	`WideRationalBasis3d basis,`
	`581`	`Vector3d localPoint,`
	`582`	`Vector3d localDisplacement,`
	`583`	`Vector3d localTranslation,`
	`584`	`FixedPointAnchorTerm3d exactLocalTerm)`
	`585`	`{`
1149	`586`	`Signed320 roundedNumerator = WideArithmetic.AddSigned320(`
1149	`587`	`WideArithmetic.MultiplySigned192(`
1149	`588`	`Signed192.Raw(origin),`
1149	`589`	`basis.Denominator),`
1149	`590`	`WideArithmetic.AddSigned320(`
1149	`591`	`WideArithmetic.AddSigned320(`
1149	`592`	`WideArithmetic.GetDotProduct3D(`
1149	`593`	`Signed192.Raw(localPoint.X),`
1149	`594`	`Signed192.Raw(localPoint.Y),`
1149	`595`	`Signed192.Raw(localPoint.Z),`
1149	`596`	`axisX,`
1149	`597`	`axisY,`
1149	`598`	`axisZ),`
1149	`599`	`WideArithmetic.GetDotProduct3D(`
1149	`600`	`Signed192.Raw(localDisplacement.X),`
1149	`601`	`Signed192.Raw(localDisplacement.Y),`
1149	`602`	`Signed192.Raw(localDisplacement.Z),`
1149	`603`	`axisX,`
1149	`604`	`axisY,`
1149	`605`	`axisZ)),`
1149	`606`	`WideArithmetic.GetDotProduct3D(`
1149	`607`	`Signed192.Raw(localTranslation.X),`
1149	`608`	`Signed192.Raw(localTranslation.Y),`
1149	`609`	`Signed192.Raw(localTranslation.Z),`
1149	`610`	`axisX,`
1149	`611`	`axisY,`
1149	`612`	`axisZ)));`
1149	`613`	`Signed576 scaledRounded = WideArithmetic.MultiplySigned320(`
1149	`614`	`roundedNumerator,`
1149	`615`	`Signed320.ExtendValue(`
1149	`616`	`FixedPointAnchorTerm3d.Denominator));`
1149	`617`	`Signed320 residualProjection = WideArithmetic.GetDotProduct3D(`
1149	`618`	`Signed192.Signed(exactLocalTerm.X),`
1149	`619`	`Signed192.Signed(exactLocalTerm.Y),`
1149	`620`	`Signed192.Signed(exactLocalTerm.Z),`
1149	`621`	`axisX,`
1149	`622`	`axisY,`
1149	`623`	`axisZ);`
1149	`624`	`return WideArithmetic.AddSigned320(`
1149	`625`	`Signed320.NarrowValue(scaledRounded),`
1149	`626`	`residualProjection);`
	`627`	`}`
	`628`
	`629`	`private static Signed320 GetAnchorDenominator(WideRationalBasis3d basis) =>`
383	`630`	`WideArithmetic.MultiplySigned192(`
383	`631`	`basis.Denominator,`
383	`632`	`FixedPointAnchorTerm3d.Denominator);`
	`633`
	`634`	`private static Signed320 GetAnchorDeltaNumerator(`
	`635`	`Fixed64 pointOrigin,`
	`636`	`Fixed64 frameOrigin,`
	`637`	`Signed192 axisX,`
	`638`	`Signed192 axisY,`
	`639`	`Signed192 axisZ,`
	`640`	`WideRationalBasis3d pointBasis,`
	`641`	`Vector3d pointLocalPoint,`
	`642`	`Vector3d pointLocalDisplacement,`
	`643`	`Vector3d pointLocalTranslation,`
	`644`	`FixedPointAnchorTerm3d exactLocalTerm,`
	`645`	`Signed320 pointDenominator) =>`
192	`646`	`WideArithmetic.SubtractSigned320(`
192	`647`	`GetAnchorCoordinateNumerator(`
192	`648`	`pointOrigin,`
192	`649`	`axisX,`
192	`650`	`axisY,`
192	`651`	`axisZ,`
192	`652`	`pointBasis,`
192	`653`	`pointLocalPoint,`
192	`654`	`pointLocalDisplacement,`
192	`655`	`pointLocalTranslation,`
192	`656`	`exactLocalTerm),`
192	`657`	`WideArithmetic.MultiplySigned192(`
192	`658`	`Signed192.Raw(frameOrigin),`
192	`659`	`Signed192.NarrowValue(pointDenominator)));`
	`660`
	`661`	`private static Signed576 GetWideProjection(`
	`662`	`Signed320 x,`
	`663`	`Signed320 y,`
	`664`	`Signed320 z,`
	`665`	`Signed192 axisX,`
	`666`	`Signed192 axisY,`
	`667`	`Signed192 axisZ) =>`
192	`668`	`WideArithmetic.AddSigned576(`
192	`669`	`WideArithmetic.AddSigned576(`
192	`670`	`WideArithmetic.MultiplySigned320(`
192	`671`	`x,`
192	`672`	`Signed320.ExtendValue(axisX)),`
192	`673`	`WideArithmetic.MultiplySigned320(`
192	`674`	`y,`
192	`675`	`Signed320.ExtendValue(axisY))),`
192	`676`	`WideArithmetic.MultiplySigned320(`
192	`677`	`z,`
192	`678`	`Signed320.ExtendValue(axisZ)));`
	`679`
	`680`	`private static bool TryGetScaledExactCoordinate(`
	`681`	`Signed576 numerator,`
	`682`	`Signed576 denominator,`
	`683`	`Fixed64 scale,`
	`684`	`out Fixed64 coordinate)`
	`685`	`{`
72	`686`	`if (scale == Fixed64.One)`
	`687`	`{`
69	`688`	`return Fixed64.TryGetSignedRawRatio(`
69	`689`	`numerator,`
69	`690`	`denominator,`
69	`691`	`out coordinate);`
	`692`	`}`
3	`693`	`return Fixed64.TryGetSignedRawRatio(`
3	`694`	`WideArithmetic.MultiplySigned576ToSigned704(`
3	`695`	`numerator,`
3	`696`	`Signed320.ExtendValue(Signed192.Raw(scale))),`
3	`697`	`WideArithmetic.MultiplySigned576ToSigned704(`
3	`698`	`denominator,`
3	`699`	`Signed320.ExtendValue(Signed192.One)),`
3	`700`	`out coordinate);`
	`701`	`}`
	`702`	`}`

Methods/Properties