< Summary

Information
Class: Gravitas.CollisionHandling.ContactResponseArithmetic3D
Assembly: Gravitas
File(s): /home/runner/work/Gravitas/Gravitas/src/Gravitas/CollisionHandling/Response/3D/ContactResponseArithmetic3D.cs
Line coverage
100%
Covered lines: 347
Uncovered lines: 0
Coverable lines: 347
Total lines: 578
Line coverage: 100%
Branch coverage
100%
Covered branches: 74
Total branches: 74
Branch coverage: 100%
Method coverage

Feature is only available for sponsors

Upgrade to PRO version

Metrics

File(s)

/home/runner/work/Gravitas/Gravitas/src/Gravitas/CollisionHandling/Response/3D/ContactResponseArithmetic3D.cs

#LineLine coverage
 1//=======================================================================
 2// ContactResponseArithmetic3D.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
 8using System.Runtime.CompilerServices;
 9using FixedMathSharp;
 10using FixedMathSharp.Geometry;
 11
 12namespace Gravitas.CollisionHandling;
 13
 14/// <summary>
 15/// Preserves the existing compact response arithmetic when a conservative
 16/// operand bound proves every intermediate representable, otherwise delegates
 17/// to FixedMathSharp's checked full-domain operations.
 18/// </summary>
 19internal static class ContactResponseArithmetic3D
 20{
 21    // For Q32.32 raw magnitudes below 2^n, one product lands below
 22    // 2^(2n-32). The 46/40/37 bounds leave sign-and-sum headroom for,
 23    // respectively, three products, the point-velocity chain, and the
 24    // cross/matrix/cross/dot angular-response chain.
 25    private const int SafeProductMagnitudeShift = 46;
 26    private const int SafePointVelocityMagnitudeShift = 40;
 27    private const int SafeAngularResponseMagnitudeShift = 37;
 28
 29    [MethodImpl(MethodImplOptions.AggressiveInlining)]
 30    internal static bool CanUseFastPointVelocity(
 31        Vector3d linearA,
 32        Vector3d angularA,
 33        Vector3d leverA,
 34        Vector3d linearB,
 35        Vector3d angularB,
 36        Vector3d leverB,
 37        Vector3d axis) =>
 117456038        IsSafeMagnitude(
 117456039            GetAggregateMagnitude(linearA)
 117456040            | GetAggregateMagnitude(angularA)
 117456041            | GetAggregateMagnitude(leverA)
 117456042            | GetAggregateMagnitude(linearB)
 117456043            | GetAggregateMagnitude(angularB)
 117456044            | GetAggregateMagnitude(leverB)
 117456045            | GetAggregateMagnitude(axis),
 117456046            SafePointVelocityMagnitudeShift);
 47
 48    [MethodImpl(MethodImplOptions.AggressiveInlining)]
 49    internal static bool CanUseFastAngularResponse(
 50        Vector3d lever,
 51        Vector3d vector,
 52        Fixed3x3 inverseInertia) =>
 65238253        IsSafeMagnitude(
 65238254            GetAggregateMagnitude(lever)
 65238255            | GetAggregateMagnitude(vector)
 65238256            | GetAggregateMagnitude(inverseInertia),
 65238257            SafeAngularResponseMagnitudeShift);
 58
 59    internal static bool TryGetRelativePointVelocity(
 60        Vector3d linearA,
 61        Vector3d angularA,
 62        Vector3d leverA,
 63        Vector3d linearB,
 64        Vector3d angularB,
 65        Vector3d leverB,
 66        Vector3d axis,
 67        out Vector3d relativeVelocity)
 68    {
 8003369        if (CanUseFastPointVelocity(
 8003370                linearA,
 8003371                angularA,
 8003372                leverA,
 8003373                linearB,
 8003374                angularB,
 8003375                leverB,
 8003376                axis))
 77        {
 8002578            Vector3d fastAngularVelocityA =
 8002579                Vector3d.Cross(angularA, leverA);
 8002580            Vector3d fastAngularVelocityB =
 8002581                Vector3d.Cross(angularB, leverB);
 8002582            if (!PreservesNonzeroCrossProduct(
 8002583                    angularA,
 8002584                    leverA,
 8002585                    fastAngularVelocityA)
 8002586                || !PreservesNonzeroCrossProduct(
 8002587                    angularB,
 8002588                    leverB,
 8002589                    fastAngularVelocityB))
 90            {
 291                relativeVelocity = default;
 292                return false;
 93            }
 94
 8002395            Vector3d fastPointVelocityA =
 8002396                linearA + fastAngularVelocityA;
 8002397            Vector3d fastPointVelocityB =
 8002398                linearB + fastAngularVelocityB;
 8002399            relativeVelocity =
 80023100                fastPointVelocityB - fastPointVelocityA;
 80023101            return true;
 102        }
 103
 8104        bool firstCrossResolved = TryCross(
 8105                angularA,
 8106                leverA,
 8107                out Vector3d angularVelocityA);
 8108        bool secondCrossResolved = TryCross(
 8109                angularB,
 8110                leverB,
 8111                out Vector3d angularVelocityB);
 8112        bool pointVelocitiesResolved = firstCrossResolved
 8113            & secondCrossResolved
 8114            & Vector3d.TryAdd(
 8115                linearA,
 8116                angularVelocityA,
 8117                out Vector3d pointVelocityA)
 8118            & Vector3d.TryAdd(
 8119                linearB,
 8120                angularVelocityB,
 8121                out Vector3d pointVelocityB);
 8122        if (!pointVelocitiesResolved)
 123        {
 2124            relativeVelocity = default;
 2125            return false;
 126        }
 127
 6128        return Vector3d.TrySubtract(
 6129            pointVelocityB,
 6130            pointVelocityA,
 6131            out relativeVelocity);
 132    }
 133
 134    [MethodImpl(MethodImplOptions.AggressiveInlining)]
 135    internal static bool TryCross(
 136        Vector3d left,
 137        Vector3d right,
 138        out Vector3d result)
 139    {
 96076140        if (HasSafeProductInputs(left, right))
 141        {
 95999142            result = Vector3d.Cross(left, right);
 95999143            return PreservesNonzeroCrossProduct(
 95999144                left,
 95999145                right,
 95999146                result);
 147        }
 148
 77149        return Vector3d.TryCross(left, right, out result)
 77150            && PreservesNonzeroCrossProduct(left, right, result);
 151    }
 152
 153    [MethodImpl(MethodImplOptions.AggressiveInlining)]
 154    internal static bool TryDot(
 155        Vector3d left,
 156        Vector3d right,
 157        out Fixed64 result)
 158    {
 194734159        if (HasSafeProductInputs(left, right))
 160        {
 194704161            result = Vector3d.Dot(left, right);
 194704162            return PreservesNonzeroDotProduct(
 194704163                left,
 194704164                right,
 194704165                result);
 166        }
 167
 30168        return Vector3d.TryDot(left, right, out result)
 30169            && PreservesNonzeroDotProduct(left, right, result);
 170    }
 171
 172    [MethodImpl(MethodImplOptions.AggressiveInlining)]
 173    internal static bool TryTransformDirection(
 174        Fixed3x3 matrix,
 175        Vector3d direction,
 176        out Vector3d result)
 177    {
 3951178        if (HasSafeProductInputs(matrix, direction))
 179        {
 3893180            result = Fixed3x3.TransformDirection(matrix, direction);
 3893181            return PreservesNonzeroTransformDirection(
 3893182                matrix,
 3893183                direction,
 3893184                result);
 185        }
 186
 58187        return Fixed3x3.TryTransformDirection(
 58188            matrix,
 58189            direction,
 58190            out result)
 58191            && PreservesNonzeroTransformDirection(matrix, direction, result);
 192    }
 193
 194    [MethodImpl(MethodImplOptions.AggressiveInlining)]
 195    internal static bool TryLinearCombination(
 196        Vector3d first,
 197        Fixed64 firstScale,
 198        Vector3d second,
 199        Fixed64 secondScale,
 200        Vector3d third,
 201        Fixed64 thirdScale,
 202        out Vector3d result)
 203    {
 37705204        if (HasSafeProductInputs(
 37705205                first,
 37705206                firstScale,
 37705207                second,
 37705208                secondScale,
 37705209                third,
 37705210                thirdScale))
 211        {
 37692212            result = first * firstScale
 37692213                + second * secondScale
 37692214                + third * thirdScale;
 37692215            return PreservesNonzeroLinearCombination(
 37692216                first,
 37692217                firstScale,
 37692218                second,
 37692219                secondScale,
 37692220                third,
 37692221                thirdScale,
 37692222                result);
 223        }
 224
 13225        return Vector3d.TryLinearCombination(
 13226            first,
 13227            firstScale,
 13228            second,
 13229            secondScale,
 13230            third,
 13231            thirdScale,
 13232            out result)
 13233            && PreservesNonzeroLinearCombination(
 13234                first,
 13235                firstScale,
 13236                second,
 13237                secondScale,
 13238                third,
 13239                thirdScale,
 13240                result);
 241    }
 242
 243    [MethodImpl(MethodImplOptions.AggressiveInlining)]
 244    internal static bool TryScale(
 245        Vector3d value,
 246        Fixed64 scale,
 247        out Vector3d result)
 248    {
 680472249        if (HasSafeProductInputs(value, scale))
 250        {
 680414251            result = value * scale;
 680414252            return true;
 253        }
 254
 58255        bool resolved = Fixed64.TryMultiplyDivide(
 58256                value.X,
 58257                scale,
 58258                Fixed64.One,
 58259                out Fixed64 x)
 58260            & Fixed64.TryMultiplyDivide(
 58261                value.Y,
 58262                scale,
 58263                Fixed64.One,
 58264                out Fixed64 y)
 58265            & Fixed64.TryMultiplyDivide(
 58266                value.Z,
 58267                scale,
 58268                Fixed64.One,
 58269                out Fixed64 z);
 58270        result = resolved ? new Vector3d(x, y, z) : default;
 58271        return resolved;
 272    }
 273
 274    internal static bool PreservesNonzeroCrossProduct(
 275        Vector3d left,
 276        Vector3d right,
 277        Vector3d result)
 278    {
 587375279        bool inspectX = result.X == Fixed64.Zero
 587375280            && HasNonzeroDifferenceTerm(
 587375281                left.Y,
 587375282                right.Z,
 587375283                left.Z,
 587375284                right.Y);
 587375285        bool inspectY = result.Y == Fixed64.Zero
 587375286            && HasNonzeroDifferenceTerm(
 587375287                left.Z,
 587375288                right.X,
 587375289                left.X,
 587375290                right.Z);
 587375291        bool inspectZ = result.Z == Fixed64.Zero
 587375292            && HasNonzeroDifferenceTerm(
 587375293                left.X,
 587375294                right.Y,
 587375295                left.Y,
 587375296                right.X);
 587375297        if (!(inspectX | inspectY | inspectZ))
 581745298            return true;
 299
 5630300        WideGeometry.GetDifferenceCrossProduct3D(
 5630301            left.X, Fixed64.Zero,
 5630302            left.Y, Fixed64.Zero,
 5630303            left.Z, Fixed64.Zero,
 5630304            right.X, Fixed64.Zero,
 5630305            right.Y, Fixed64.Zero,
 5630306            right.Z, Fixed64.Zero,
 5630307            out Signed192 exactX,
 5630308            out Signed192 exactY,
 5630309            out Signed192 exactZ);
 5630310        return PreservesExactValue(inspectX, exactX)
 5630311            & PreservesExactValue(inspectY, exactY)
 5630312            & PreservesExactValue(inspectZ, exactZ);
 313    }
 314
 315    internal static bool PreservesNonzeroDotProduct(
 316        Vector3d left,
 317        Vector3d right,
 318        Fixed64 result)
 319    {
 347070320        if (result != Fixed64.Zero
 347070321            || !HasNonzeroTerm(
 347070322                left.X,
 347070323                right.X,
 347070324                left.Y,
 347070325                right.Y,
 347070326                left.Z,
 347070327                right.Z))
 328        {
 344768329            return true;
 330        }
 331
 2302332        return GetLinearCombinationComponent(
 2302333            left.X,
 2302334            right.X,
 2302335            left.Y,
 2302336            right.Y,
 2302337            left.Z,
 2302338            right.Z).IsZero;
 339    }
 340
 341    internal static bool PreservesNonzeroTransformDirection(
 342        Fixed3x3 matrix,
 343        Vector3d direction,
 344        Vector3d result)
 345    {
 220462346        bool inspectX = result.X == Fixed64.Zero
 220462347            && HasNonzeroTerm(
 220462348                direction.X,
 220462349                matrix.M11,
 220462350                direction.Y,
 220462351                matrix.M21,
 220462352                direction.Z,
 220462353                matrix.M31);
 220462354        bool inspectY = result.Y == Fixed64.Zero
 220462355            && HasNonzeroTerm(
 220462356                direction.X,
 220462357                matrix.M12,
 220462358                direction.Y,
 220462359                matrix.M22,
 220462360                direction.Z,
 220462361                matrix.M32);
 220462362        bool inspectZ = result.Z == Fixed64.Zero
 220462363            && HasNonzeroTerm(
 220462364                direction.X,
 220462365                matrix.M13,
 220462366                direction.Y,
 220462367                matrix.M23,
 220462368                direction.Z,
 220462369                matrix.M33);
 220462370        if (!(inspectX | inspectY | inspectZ))
 209694371            return true;
 372
 10768373        Signed192 exactX = GetLinearCombinationComponent(
 10768374            direction.X,
 10768375            matrix.M11,
 10768376            direction.Y,
 10768377            matrix.M21,
 10768378            direction.Z,
 10768379            matrix.M31);
 10768380        Signed192 exactY = GetLinearCombinationComponent(
 10768381            direction.X,
 10768382            matrix.M12,
 10768383            direction.Y,
 10768384            matrix.M22,
 10768385            direction.Z,
 10768386            matrix.M32);
 10768387        Signed192 exactZ = GetLinearCombinationComponent(
 10768388            direction.X,
 10768389            matrix.M13,
 10768390            direction.Y,
 10768391            matrix.M23,
 10768392            direction.Z,
 10768393            matrix.M33);
 10768394        return PreservesExactValue(inspectX, exactX)
 10768395            & PreservesExactValue(inspectY, exactY)
 10768396            & PreservesExactValue(inspectZ, exactZ);
 397    }
 398
 399    private static bool PreservesNonzeroLinearCombination(
 400        Vector3d first,
 401        Fixed64 firstScale,
 402        Vector3d second,
 403        Fixed64 secondScale,
 404        Vector3d third,
 405        Fixed64 thirdScale,
 406        Vector3d result)
 407    {
 37702408        bool inspectX = result.X == Fixed64.Zero
 37702409            && HasNonzeroTerm(
 37702410                first.X,
 37702411                firstScale,
 37702412                second.X,
 37702413                secondScale,
 37702414                third.X,
 37702415                thirdScale);
 37702416        bool inspectY = result.Y == Fixed64.Zero
 37702417            && HasNonzeroTerm(
 37702418                first.Y,
 37702419                firstScale,
 37702420                second.Y,
 37702421                secondScale,
 37702422                third.Y,
 37702423                thirdScale);
 37702424        bool inspectZ = result.Z == Fixed64.Zero
 37702425            && HasNonzeroTerm(
 37702426                first.Z,
 37702427                firstScale,
 37702428                second.Z,
 37702429                secondScale,
 37702430                third.Z,
 37702431                thirdScale);
 37702432        if (!(inspectX | inspectY | inspectZ))
 37687433            return true;
 434
 15435        Signed192 exactX = GetLinearCombinationComponent(
 15436            first.X,
 15437            firstScale,
 15438            second.X,
 15439            secondScale,
 15440            third.X,
 15441            thirdScale);
 15442        Signed192 exactY = GetLinearCombinationComponent(
 15443            first.Y,
 15444            firstScale,
 15445            second.Y,
 15446            secondScale,
 15447            third.Y,
 15448            thirdScale);
 15449        Signed192 exactZ = GetLinearCombinationComponent(
 15450            first.Z,
 15451            firstScale,
 15452            second.Z,
 15453            secondScale,
 15454            third.Z,
 15455            thirdScale);
 15456        return PreservesExactValue(inspectX, exactX)
 15457            & PreservesExactValue(inspectY, exactY)
 15458            & PreservesExactValue(inspectZ, exactZ);
 459    }
 460
 461    [MethodImpl(MethodImplOptions.AggressiveInlining)]
 462    private static bool PreservesExactValue(
 463        bool inspect,
 464        Signed192 exact) =>
 49239465        !inspect || exact.IsZero;
 466
 467    [MethodImpl(MethodImplOptions.AggressiveInlining)]
 468    private static bool HasSafeProductInputs(
 469        Vector3d left,
 470        Vector3d right) =>
 290810471        IsSafeMagnitude(
 290810472            GetAggregateMagnitude(left)
 290810473            | GetAggregateMagnitude(right),
 290810474            SafeProductMagnitudeShift);
 475
 476    [MethodImpl(MethodImplOptions.AggressiveInlining)]
 477    private static bool HasSafeProductInputs(
 478        Fixed3x3 matrix,
 479        Vector3d direction) =>
 3951480        IsSafeMagnitude(
 3951481            GetAggregateMagnitude(matrix)
 3951482            | GetAggregateMagnitude(direction),
 3951483            SafeProductMagnitudeShift);
 484
 485    [MethodImpl(MethodImplOptions.AggressiveInlining)]
 486    private static bool HasSafeProductInputs(
 487        Vector3d first,
 488        Fixed64 firstScale,
 489        Vector3d second,
 490        Fixed64 secondScale,
 491        Vector3d third,
 492        Fixed64 thirdScale) =>
 37705493        IsSafeMagnitude(
 37705494            GetAggregateMagnitude(first)
 37705495            | GetRawMagnitude(firstScale)
 37705496            | GetAggregateMagnitude(second)
 37705497            | GetRawMagnitude(secondScale)
 37705498            | GetAggregateMagnitude(third)
 37705499            | GetRawMagnitude(thirdScale),
 37705500            SafeProductMagnitudeShift);
 501
 502    [MethodImpl(MethodImplOptions.AggressiveInlining)]
 503    private static bool HasSafeProductInputs(
 504        Vector3d value,
 505        Fixed64 scale) =>
 680472506        IsSafeMagnitude(
 680472507            GetAggregateMagnitude(value)
 680472508            | GetRawMagnitude(scale),
 680472509            SafeProductMagnitudeShift);
 510
 511    [MethodImpl(MethodImplOptions.AggressiveInlining)]
 512    private static bool HasNonzeroTerm(
 513        Fixed64 first,
 514        Fixed64 firstScale,
 515        Fixed64 second,
 516        Fixed64 secondScale,
 517        Fixed64 third,
 518        Fixed64 thirdScale) =>
 823849519        (first != Fixed64.Zero && firstScale != Fixed64.Zero)
 823849520        || (second != Fixed64.Zero && secondScale != Fixed64.Zero)
 823849521        || (third != Fixed64.Zero && thirdScale != Fixed64.Zero);
 522
 523    [MethodImpl(MethodImplOptions.AggressiveInlining)]
 524    private static bool HasNonzeroDifferenceTerm(
 525        Fixed64 first,
 526        Fixed64 firstScale,
 527        Fixed64 second,
 528        Fixed64 secondScale) =>
 1398342529        (first != Fixed64.Zero && firstScale != Fixed64.Zero)
 1398342530        || (second != Fixed64.Zero && secondScale != Fixed64.Zero);
 531
 532    private static Signed192 GetLinearCombinationComponent(
 533        Fixed64 first,
 534        Fixed64 firstScale,
 535        Fixed64 second,
 536        Fixed64 secondScale,
 537        Fixed64 third,
 538        Fixed64 thirdScale) =>
 34651539        WideGeometry.GetDifferenceDotProduct3D(
 34651540            first, Fixed64.Zero,
 34651541            second, Fixed64.Zero,
 34651542            third, Fixed64.Zero,
 34651543            firstScale, Fixed64.Zero,
 34651544            secondScale, Fixed64.Zero,
 34651545            thirdScale, Fixed64.Zero);
 546
 547    [MethodImpl(MethodImplOptions.AggressiveInlining)]
 548    private static bool IsSafeMagnitude(
 549        ulong aggregateMagnitude,
 550        int shift) =>
 2839880551        (aggregateMagnitude >> shift) == 0UL;
 552
 553    [MethodImpl(MethodImplOptions.AggressiveInlining)]
 554    private static ulong GetAggregateMagnitude(Vector3d value) =>
 10905842555        GetRawMagnitude(value.X)
 10905842556        | GetRawMagnitude(value.Y)
 10905842557        | GetRawMagnitude(value.Z);
 558
 559    [MethodImpl(MethodImplOptions.AggressiveInlining)]
 560    private static ulong GetAggregateMagnitude(Fixed3x3 matrix) =>
 656333561        GetRawMagnitude(matrix.M11)
 656333562        | GetRawMagnitude(matrix.M12)
 656333563        | GetRawMagnitude(matrix.M13)
 656333564        | GetRawMagnitude(matrix.M21)
 656333565        | GetRawMagnitude(matrix.M22)
 656333566        | GetRawMagnitude(matrix.M23)
 656333567        | GetRawMagnitude(matrix.M31)
 656333568        | GetRawMagnitude(matrix.M32)
 656333569        | GetRawMagnitude(matrix.M33);
 570
 571    [MethodImpl(MethodImplOptions.AggressiveInlining)]
 572    private static ulong GetRawMagnitude(Fixed64 value)
 573    {
 39418110574        ulong raw = unchecked((ulong)value.m_rawValue);
 39418110575        ulong sign = unchecked((ulong)(value.m_rawValue >> 63));
 39418110576        return (raw ^ sign) - sign;
 577    }
 578}

Methods/Properties

CanUseFastPointVelocity(FixedMathSharp.Vector3d,FixedMathSharp.Vector3d,FixedMathSharp.Vector3d,FixedMathSharp.Vector3d,FixedMathSharp.Vector3d,FixedMathSharp.Vector3d,FixedMathSharp.Vector3d)
CanUseFastAngularResponse(FixedMathSharp.Vector3d,FixedMathSharp.Vector3d,FixedMathSharp.Fixed3x3)
TryGetRelativePointVelocity(FixedMathSharp.Vector3d,FixedMathSharp.Vector3d,FixedMathSharp.Vector3d,FixedMathSharp.Vector3d,FixedMathSharp.Vector3d,FixedMathSharp.Vector3d,FixedMathSharp.Vector3d,FixedMathSharp.Vector3d&)
TryCross(FixedMathSharp.Vector3d,FixedMathSharp.Vector3d,FixedMathSharp.Vector3d&)
TryDot(FixedMathSharp.Vector3d,FixedMathSharp.Vector3d,FixedMathSharp.Fixed64&)
TryTransformDirection(FixedMathSharp.Fixed3x3,FixedMathSharp.Vector3d,FixedMathSharp.Vector3d&)
TryLinearCombination(FixedMathSharp.Vector3d,FixedMathSharp.Fixed64,FixedMathSharp.Vector3d,FixedMathSharp.Fixed64,FixedMathSharp.Vector3d,FixedMathSharp.Fixed64,FixedMathSharp.Vector3d&)
TryScale(FixedMathSharp.Vector3d,FixedMathSharp.Fixed64,FixedMathSharp.Vector3d&)
PreservesNonzeroCrossProduct(FixedMathSharp.Vector3d,FixedMathSharp.Vector3d,FixedMathSharp.Vector3d)
PreservesNonzeroDotProduct(FixedMathSharp.Vector3d,FixedMathSharp.Vector3d,FixedMathSharp.Fixed64)
PreservesNonzeroTransformDirection(FixedMathSharp.Fixed3x3,FixedMathSharp.Vector3d,FixedMathSharp.Vector3d)
PreservesNonzeroLinearCombination(FixedMathSharp.Vector3d,FixedMathSharp.Fixed64,FixedMathSharp.Vector3d,FixedMathSharp.Fixed64,FixedMathSharp.Vector3d,FixedMathSharp.Fixed64,FixedMathSharp.Vector3d)
PreservesExactValue(System.Boolean,FixedMathSharp.Signed192)
HasSafeProductInputs(FixedMathSharp.Vector3d,FixedMathSharp.Vector3d)
HasSafeProductInputs(FixedMathSharp.Fixed3x3,FixedMathSharp.Vector3d)
HasSafeProductInputs(FixedMathSharp.Vector3d,FixedMathSharp.Fixed64,FixedMathSharp.Vector3d,FixedMathSharp.Fixed64,FixedMathSharp.Vector3d,FixedMathSharp.Fixed64)
HasSafeProductInputs(FixedMathSharp.Vector3d,FixedMathSharp.Fixed64)
HasNonzeroTerm(FixedMathSharp.Fixed64,FixedMathSharp.Fixed64,FixedMathSharp.Fixed64,FixedMathSharp.Fixed64,FixedMathSharp.Fixed64,FixedMathSharp.Fixed64)
HasNonzeroDifferenceTerm(FixedMathSharp.Fixed64,FixedMathSharp.Fixed64,FixedMathSharp.Fixed64,FixedMathSharp.Fixed64)
GetLinearCombinationComponent(FixedMathSharp.Fixed64,FixedMathSharp.Fixed64,FixedMathSharp.Fixed64,FixedMathSharp.Fixed64,FixedMathSharp.Fixed64,FixedMathSharp.Fixed64)
IsSafeMagnitude(System.UInt64,System.Int32)
GetAggregateMagnitude(FixedMathSharp.Vector3d)
GetAggregateMagnitude(FixedMathSharp.Fixed3x3)
GetRawMagnitude(FixedMathSharp.Fixed64)