< 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

MethodBranch coverage Crap Score Cyclomatic complexity Line coverage
CanUseFastPointVelocity(...)100%11100%
CanUseFastAngularResponse(...)100%11100%
TryGetRelativePointVelocity(...)100%88100%
TryCross(...)100%44100%
TryDot(...)100%44100%
TryTransformDirection(...)100%44100%
TryLinearCombination(...)100%44100%
TryScale(...)100%44100%
PreservesNonzeroCrossProduct(...)100%88100%
PreservesNonzeroDotProduct(...)100%44100%
PreservesNonzeroTransformDirection(...)100%88100%
PreservesNonzeroLinearCombination(...)100%88100%
PreservesExactValue(...)100%22100%
HasSafeProductInputs(...)100%11100%
HasSafeProductInputs(...)100%11100%
HasSafeProductInputs(...)100%11100%
HasSafeProductInputs(...)100%11100%
HasNonzeroTerm(...)100%1010100%
HasNonzeroDifferenceTerm(...)100%66100%
GetLinearCombinationComponent(...)100%11100%
IsSafeMagnitude(...)100%11100%
GetAggregateMagnitude(...)100%11100%
GetAggregateMagnitude(...)100%11100%
GetRawMagnitude(...)100%11100%

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 FixedMathSharp;
 9using FixedMathSharp.Geometry;
 10using System.Runtime.CompilerServices;
 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) =>
 1882538        IsSafeMagnitude(
 1882539            GetAggregateMagnitude(linearA)
 1882540            | GetAggregateMagnitude(angularA)
 1882541            | GetAggregateMagnitude(leverA)
 1882542            | GetAggregateMagnitude(linearB)
 1882543            | GetAggregateMagnitude(angularB)
 1882544            | GetAggregateMagnitude(leverB)
 1882545            | GetAggregateMagnitude(axis),
 1882546            SafePointVelocityMagnitudeShift);
 47
 48    [MethodImpl(MethodImplOptions.AggressiveInlining)]
 49    internal static bool CanUseFastAngularResponse(
 50        Vector3d lever,
 51        Vector3d vector,
 52        Fixed3x3 inverseInertia) =>
 5844053        IsSafeMagnitude(
 5844054            GetAggregateMagnitude(lever)
 5844055            | GetAggregateMagnitude(vector)
 5844056            | GetAggregateMagnitude(inverseInertia),
 5844057            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    {
 697569        if (CanUseFastPointVelocity(
 697570                linearA,
 697571                angularA,
 697572                leverA,
 697573                linearB,
 697574                angularB,
 697575                leverB,
 697576                axis))
 77        {
 696778            Vector3d fastAngularVelocityA =
 696779                Vector3d.Cross(angularA, leverA);
 696780            Vector3d fastAngularVelocityB =
 696781                Vector3d.Cross(angularB, leverB);
 696782            if (!PreservesNonzeroCrossProduct(
 696783                    angularA,
 696784                    leverA,
 696785                    fastAngularVelocityA)
 696786                || !PreservesNonzeroCrossProduct(
 696787                    angularB,
 696788                    leverB,
 696789                    fastAngularVelocityB))
 90            {
 33791                relativeVelocity = default;
 33792                return false;
 93            }
 94
 663095            Vector3d fastPointVelocityA =
 663096                linearA + fastAngularVelocityA;
 663097            Vector3d fastPointVelocityB =
 663098                linearB + fastAngularVelocityB;
 663099            relativeVelocity =
 6630100                fastPointVelocityB - fastPointVelocityA;
 6630101            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    {
 15017140        if (HasSafeProductInputs(left, right))
 141        {
 14979142            result = Vector3d.Cross(left, right);
 14979143            return PreservesNonzeroCrossProduct(
 14979144                left,
 14979145                right,
 14979146                result);
 147        }
 148
 38149        return Vector3d.TryCross(left, right, out result)
 38150            && 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    {
 14214159        if (HasSafeProductInputs(left, right))
 160        {
 14188161            result = Vector3d.Dot(left, right);
 14188162            return PreservesNonzeroDotProduct(
 14188163                left,
 14188164                right,
 14188165                result);
 166        }
 167
 26168        return Vector3d.TryDot(left, right, out result)
 26169            && 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    {
 26178        if (HasSafeProductInputs(matrix, direction))
 179        {
 15180            result = Fixed3x3.TransformDirection(matrix, direction);
 15181            return PreservesNonzeroTransformDirection(
 15182                matrix,
 15183                direction,
 15184                result);
 185        }
 186
 11187        return Fixed3x3.TryTransformDirection(
 11188            matrix,
 11189            direction,
 11190            out result)
 11191            && 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    {
 6257204        if (HasSafeProductInputs(
 6257205                first,
 6257206                firstScale,
 6257207                second,
 6257208                secondScale,
 6257209                third,
 6257210                thirdScale))
 211        {
 6249212            result = first * firstScale
 6249213                + second * secondScale
 6249214                + third * thirdScale;
 6249215            return PreservesNonzeroLinearCombination(
 6249216                first,
 6249217                firstScale,
 6249218                second,
 6249219                secondScale,
 6249220                third,
 6249221                thirdScale,
 6249222                result);
 223        }
 224
 8225        return Vector3d.TryLinearCombination(
 8226            first,
 8227            firstScale,
 8228            second,
 8229            secondScale,
 8230            third,
 8231            thirdScale,
 8232            out result)
 8233            && PreservesNonzeroLinearCombination(
 8234                first,
 8235                firstScale,
 8236                second,
 8237                secondScale,
 8238                third,
 8239                thirdScale,
 8240                result);
 241    }
 242
 243    [MethodImpl(MethodImplOptions.AggressiveInlining)]
 244    internal static bool TryScale(
 245        Vector3d value,
 246        Fixed64 scale,
 247        out Vector3d result)
 248    {
 11832249        if (HasSafeProductInputs(value, scale))
 250        {
 11821251            result = value * scale;
 11821252            return true;
 253        }
 254
 11255        bool resolved = Fixed64.TryMultiplyDivide(
 11256                value.X,
 11257                scale,
 11258                Fixed64.One,
 11259                out Fixed64 x)
 11260            & Fixed64.TryMultiplyDivide(
 11261                value.Y,
 11262                scale,
 11263                Fixed64.One,
 11264                out Fixed64 y)
 11265            & Fixed64.TryMultiplyDivide(
 11266                value.Z,
 11267                scale,
 11268                Fixed64.One,
 11269                out Fixed64 z);
 11270        result = resolved ? new Vector3d(x, y, z) : default;
 11271        return resolved;
 272    }
 273
 274    internal static bool PreservesNonzeroCrossProduct(
 275        Vector3d left,
 276        Vector3d right,
 277        Vector3d result)
 278    {
 101318279        bool inspectX = result.X == Fixed64.Zero
 101318280            && HasNonzeroDifferenceTerm(
 101318281                left.Y,
 101318282                right.Z,
 101318283                left.Z,
 101318284                right.Y);
 101318285        bool inspectY = result.Y == Fixed64.Zero
 101318286            && HasNonzeroDifferenceTerm(
 101318287                left.Z,
 101318288                right.X,
 101318289                left.X,
 101318290                right.Z);
 101318291        bool inspectZ = result.Z == Fixed64.Zero
 101318292            && HasNonzeroDifferenceTerm(
 101318293                left.X,
 101318294                right.Y,
 101318295                left.Y,
 101318296                right.X);
 101318297        if (!(inspectX | inspectY | inspectZ))
 99440298            return true;
 299
 1878300        WideGeometry.GetDifferenceCrossProduct3D(
 1878301            left.X, Fixed64.Zero,
 1878302            left.Y, Fixed64.Zero,
 1878303            left.Z, Fixed64.Zero,
 1878304            right.X, Fixed64.Zero,
 1878305            right.Y, Fixed64.Zero,
 1878306            right.Z, Fixed64.Zero,
 1878307            out Signed192 exactX,
 1878308            out Signed192 exactY,
 1878309            out Signed192 exactZ);
 1878310        return PreservesExactValue(inspectX, exactX)
 1878311            & PreservesExactValue(inspectY, exactY)
 1878312            & PreservesExactValue(inspectZ, exactZ);
 313    }
 314
 315    internal static bool PreservesNonzeroDotProduct(
 316        Vector3d left,
 317        Vector3d right,
 318        Fixed64 result)
 319    {
 44326320        if (result != Fixed64.Zero
 44326321            || !HasNonzeroTerm(
 44326322                left.X,
 44326323                right.X,
 44326324                left.Y,
 44326325                right.Y,
 44326326                left.Z,
 44326327                right.Z))
 328        {
 44322329            return true;
 330        }
 331
 4332        return GetLinearCombinationComponent(
 4333            left.X,
 4334            right.X,
 4335            left.Y,
 4336            right.Y,
 4337            left.Z,
 4338            right.Z).IsZero;
 339    }
 340
 341    internal static bool PreservesNonzeroTransformDirection(
 342        Fixed3x3 matrix,
 343        Vector3d direction,
 344        Vector3d result)
 345    {
 53616346        bool inspectX = result.X == Fixed64.Zero
 53616347            && HasNonzeroTerm(
 53616348                direction.X,
 53616349                matrix.M11,
 53616350                direction.Y,
 53616351                matrix.M21,
 53616352                direction.Z,
 53616353                matrix.M31);
 53616354        bool inspectY = result.Y == Fixed64.Zero
 53616355            && HasNonzeroTerm(
 53616356                direction.X,
 53616357                matrix.M12,
 53616358                direction.Y,
 53616359                matrix.M22,
 53616360                direction.Z,
 53616361                matrix.M32);
 53616362        bool inspectZ = result.Z == Fixed64.Zero
 53616363            && HasNonzeroTerm(
 53616364                direction.X,
 53616365                matrix.M13,
 53616366                direction.Y,
 53616367                matrix.M23,
 53616368                direction.Z,
 53616369                matrix.M33);
 53616370        if (!(inspectX | inspectY | inspectZ))
 53615371            return true;
 372
 1373        Signed192 exactX = GetLinearCombinationComponent(
 1374            direction.X,
 1375            matrix.M11,
 1376            direction.Y,
 1377            matrix.M21,
 1378            direction.Z,
 1379            matrix.M31);
 1380        Signed192 exactY = GetLinearCombinationComponent(
 1381            direction.X,
 1382            matrix.M12,
 1383            direction.Y,
 1384            matrix.M22,
 1385            direction.Z,
 1386            matrix.M32);
 1387        Signed192 exactZ = GetLinearCombinationComponent(
 1388            direction.X,
 1389            matrix.M13,
 1390            direction.Y,
 1391            matrix.M23,
 1392            direction.Z,
 1393            matrix.M33);
 1394        return PreservesExactValue(inspectX, exactX)
 1395            & PreservesExactValue(inspectY, exactY)
 1396            & 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    {
 6254408        bool inspectX = result.X == Fixed64.Zero
 6254409            && HasNonzeroTerm(
 6254410                first.X,
 6254411                firstScale,
 6254412                second.X,
 6254413                secondScale,
 6254414                third.X,
 6254415                thirdScale);
 6254416        bool inspectY = result.Y == Fixed64.Zero
 6254417            && HasNonzeroTerm(
 6254418                first.Y,
 6254419                firstScale,
 6254420                second.Y,
 6254421                secondScale,
 6254422                third.Y,
 6254423                thirdScale);
 6254424        bool inspectZ = result.Z == Fixed64.Zero
 6254425            && HasNonzeroTerm(
 6254426                first.Z,
 6254427                firstScale,
 6254428                second.Z,
 6254429                secondScale,
 6254430                third.Z,
 6254431                thirdScale);
 6254432        if (!(inspectX | inspectY | inspectZ))
 6240433            return true;
 434
 14435        Signed192 exactX = GetLinearCombinationComponent(
 14436            first.X,
 14437            firstScale,
 14438            second.X,
 14439            secondScale,
 14440            third.X,
 14441            thirdScale);
 14442        Signed192 exactY = GetLinearCombinationComponent(
 14443            first.Y,
 14444            firstScale,
 14445            second.Y,
 14446            secondScale,
 14447            third.Y,
 14448            thirdScale);
 14449        Signed192 exactZ = GetLinearCombinationComponent(
 14450            first.Z,
 14451            firstScale,
 14452            second.Z,
 14453            secondScale,
 14454            third.Z,
 14455            thirdScale);
 14456        return PreservesExactValue(inspectX, exactX)
 14457            & PreservesExactValue(inspectY, exactY)
 14458            & PreservesExactValue(inspectZ, exactZ);
 459    }
 460
 461    [MethodImpl(MethodImplOptions.AggressiveInlining)]
 462    private static bool PreservesExactValue(
 463        bool inspect,
 464        Signed192 exact) =>
 5679465        !inspect || exact.IsZero;
 466
 467    [MethodImpl(MethodImplOptions.AggressiveInlining)]
 468    private static bool HasSafeProductInputs(
 469        Vector3d left,
 470        Vector3d right) =>
 29231471        IsSafeMagnitude(
 29231472            GetAggregateMagnitude(left)
 29231473            | GetAggregateMagnitude(right),
 29231474            SafeProductMagnitudeShift);
 475
 476    [MethodImpl(MethodImplOptions.AggressiveInlining)]
 477    private static bool HasSafeProductInputs(
 478        Fixed3x3 matrix,
 479        Vector3d direction) =>
 26480        IsSafeMagnitude(
 26481            GetAggregateMagnitude(matrix)
 26482            | GetAggregateMagnitude(direction),
 26483            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) =>
 6257493        IsSafeMagnitude(
 6257494            GetAggregateMagnitude(first)
 6257495            | GetRawMagnitude(firstScale)
 6257496            | GetAggregateMagnitude(second)
 6257497            | GetRawMagnitude(secondScale)
 6257498            | GetAggregateMagnitude(third)
 6257499            | GetRawMagnitude(thirdScale),
 6257500            SafeProductMagnitudeShift);
 501
 502    [MethodImpl(MethodImplOptions.AggressiveInlining)]
 503    private static bool HasSafeProductInputs(
 504        Vector3d value,
 505        Fixed64 scale) =>
 11832506        IsSafeMagnitude(
 11832507            GetAggregateMagnitude(value)
 11832508            | GetRawMagnitude(scale),
 11832509            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) =>
 172196519        (first != Fixed64.Zero && firstScale != Fixed64.Zero)
 172196520        || (second != Fixed64.Zero && secondScale != Fixed64.Zero)
 172196521        || (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) =>
 248493529        (first != Fixed64.Zero && firstScale != Fixed64.Zero)
 248493530        || (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) =>
 49539        WideGeometry.GetDifferenceDotProduct3D(
 49540            first, Fixed64.Zero,
 49541            second, Fixed64.Zero,
 49542            third, Fixed64.Zero,
 49543            firstScale, Fixed64.Zero,
 49544            secondScale, Fixed64.Zero,
 49545            thirdScale, Fixed64.Zero);
 546
 547    [MethodImpl(MethodImplOptions.AggressiveInlining)]
 548    private static bool IsSafeMagnitude(
 549        ulong aggregateMagnitude,
 550        int shift) =>
 124611551        (aggregateMagnitude >> shift) == 0UL;
 552
 553    [MethodImpl(MethodImplOptions.AggressiveInlining)]
 554    private static ulong GetAggregateMagnitude(Vector3d value) =>
 337746555        GetRawMagnitude(value.X)
 337746556        | GetRawMagnitude(value.Y)
 337746557        | GetRawMagnitude(value.Z);
 558
 559    [MethodImpl(MethodImplOptions.AggressiveInlining)]
 560    private static ulong GetAggregateMagnitude(Fixed3x3 matrix) =>
 58466561        GetRawMagnitude(matrix.M11)
 58466562        | GetRawMagnitude(matrix.M12)
 58466563        | GetRawMagnitude(matrix.M13)
 58466564        | GetRawMagnitude(matrix.M21)
 58466565        | GetRawMagnitude(matrix.M22)
 58466566        | GetRawMagnitude(matrix.M23)
 58466567        | GetRawMagnitude(matrix.M31)
 58466568        | GetRawMagnitude(matrix.M32)
 58466569        | GetRawMagnitude(matrix.M33);
 570
 571    [MethodImpl(MethodImplOptions.AggressiveInlining)]
 572    private static ulong GetRawMagnitude(Fixed64 value)
 573    {
 1570035574        ulong raw = unchecked((ulong)value.m_rawValue);
 1570035575        ulong sign = unchecked((ulong)(value.m_rawValue >> 63));
 1570035576        return (raw ^ sign) - sign;
 577    }
 578}
Generated by: ReportGenerator 5.5.11.0
08/05/2026 - 20:00:44
GitHub | reportgenerator.io

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)