< Summary

Information
Class: FixedMathSharp.Geometry.CircularRimContactAlgebra
Assembly: FixedMathSharp
File(s): /home/runner/work/FixedMathSharp/FixedMathSharp/src/FixedMathSharp/Geometry/Wide/Convex/CircularRimContactAlgebra.cs
Line coverage
100%
Covered lines: 176
Uncovered lines: 0
Coverable lines: 176
Total lines: 319
Line coverage: 100%
Branch coverage
100%
Covered branches: 44
Total branches: 44
Branch coverage: 100%
Method coverage

Feature is only available for sponsors

Upgrade to PRO version

Metrics

MethodBranch coverage Crap Score Cyclomatic complexity Line coverage
BuildParameter(...)100%44100%
GetRigidAxis(...)100%11100%
GetBasis(...)100%44100%
Transform(...)100%11100%
RadialDot(...)100%11100%
Twice(...)100%11100%
Write(...)100%22100%
WriteGradient(...)100%22100%
BuildValues(...)100%22100%
HasSegmentSupport(...)100%1818100%
BuildParameter(...)100%22100%
ReverseParameterChart(...)100%22100%
ReverseCoefficients(...)100%44100%
BuildValues(...)100%11100%
GetBasis(...)100%22100%
WriteGradient(...)100%22100%
Transform(...)100%11100%
TransformComponent(...)100%11100%
RadialDot(...)100%11100%
Twice(...)100%11100%
Sign(...)100%11100%
Write(...)100%11100%

File(s)

/home/runner/work/FixedMathSharp/FixedMathSharp/src/FixedMathSharp/Geometry/Wide/Convex/CircularRimContactAlgebra.cs

#LineLine coverage
 1//=======================================================================
 2// CircularRimContactAlgebra.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
 8using System;
 9using System.Runtime.CompilerServices;
 10using static FixedMathSharp.Geometry.CylinderContactAlgebra;
 11
 12namespace FixedMathSharp.Geometry;
 13
 14/// <summary>Exact circular-rim chart, value and direction algebra on a normal plane.</summary>
 15internal static class CircularRimContactAlgebra
 16{
 17    internal const int ValueWords = 56;
 18
 19    [MethodImpl(MethodImplOptions.NoInlining)]
 20    internal static void BuildParameter(in WideDirection3d offset, Signed576 radius, Signed320 rawScale,
 21        in WideDirection3d first, in WideDirection3d second, Span<ulong> data, Span<sbyte> signs,
 22        bool useRigidBounds = false)
 23    {
 1257224        if (useRigidBounds)
 25        {
 26            // The rigid triangle owner retains its original bounds even after
 27            // an endpoint-core shift: offsets/radius <232, chart axes <198,
 28            // and RawScale <164 bits. Reuse its existing coefficient path;
 29            // exact scaled source frames must keep the wider products below.
 836630            BuildParameter(GetRigidAxis(offset), Signed320.NarrowValue(radius), Signed192.NarrowProven(rawScale),
 836631                GetRigidAxis(first), GetRigidAxis(second), data, signs);
 836632            return;
 33        }
 420634        int words = data.Length / signs.Length;
 841235        Span<ulong> inputs = stackalloc ulong[11 * words]; Span<sbyte> inputSigns = stackalloc sbyte[9];
 841236        inputs.Clear(); inputSigns.Clear();
 841237        Span<ulong> p = inputs[..(2 * words)], q = inputs.Slice(2 * words, 3 * words),
 841238            metric = inputs.Slice(5 * words, 3 * words), scale = inputs.Slice(8 * words, words),
 841239            square = inputs.Slice(9 * words, words), product = inputs.Slice(10 * words, words);
 420640        Write(p, inputSigns[..2], 0, WideDirection3d.Dot(offset, first), words);
 420641        Write(p, inputSigns[..2], 1, WideDirection3d.Dot(offset, second), words);
 420642        Write(metric, inputSigns.Slice(5, 3), 0, first.SquaredLength, words);
 420643        Write(metric, inputSigns.Slice(5, 3), 1, Twice(WideDirection3d.Dot(first, second)), words);
 420644        Write(metric, inputSigns.Slice(5, 3), 2, second.SquaredLength, words);
 420645        Write(q, inputSigns.Slice(2, 3), 0, RadialDot(first, first), words);
 420646        Write(q, inputSigns.Slice(2, 3), 1, Twice(RadialDot(first, second)), words);
 420647        Write(q, inputSigns.Slice(2, 3), 2, RadialDot(second, second), words);
 420648        Import(WideArithmetic.MultiplySigned576ToSigned832(radius, radius), square);
 3364849        for (int index = 0; index < 3; index++)
 50        {
 1261851            WideArithmetic.MultiplyMagnitudes(q.Slice(index * words, words), square, product);
 1261852            product.CopyTo(q.Slice(index * words, words));
 53        }
 420654        Import(rawScale, scale);
 420655        CylinderEdgeContactPolynomial.Build(p, inputSigns[..2], q, inputSigns.Slice(2, 3),
 420656            metric, inputSigns.Slice(5, 3), scale, data[..(26 * words)], signs[..26]);
 420657    }
 58
 2531659    private static WideAxis3 GetRigidAxis(in WideDirection3d value) => new(
 2531660        Signed320.NarrowValue(value.X), Signed320.NarrowValue(value.Y), Signed320.NarrowValue(value.Z));
 61
 62    internal static void GetBasis(in WideDirection3d edge, out WideDirection3d first, out WideDirection3d second)
 63    {
 1208864        if (!edge.X.IsZero)
 65        {
 995066            first = new WideDirection3d(WideArithmetic.Negate(edge.Y), edge.X, default);
 995067            second = new WideDirection3d(WideArithmetic.Negate(edge.Z), default, edge.X);
 68        }
 69        else
 70        {
 213871            first = new WideDirection3d(default, WideArithmetic.Negate(edge.Z), edge.Y);
 213872            second = new WideDirection3d(edge.Y.IsZero ? edge.Z : edge.Y, default, default);
 73        }
 213874    }
 75
 35076    internal static WideDirection3d Transform(in WideRationalBasis3d basis, in WideDirection3d value) => value.Transform
 2226477    internal static Signed832 RadialDot(in WideDirection3d first, in WideDirection3d second) => WideArithmetic.AddSigned
 2226478        WideArithmetic.MultiplySigned576ToSigned832(first.X, second.X),
 2226479        WideArithmetic.MultiplySigned576ToSigned832(first.Z, second.Z));
 841280    internal static Signed832 Twice(Signed832 value) => WideArithmetic.AddSigned832(value, value);
 81    internal static void Write(Span<ulong> values, Span<sbyte> signs, int index, Signed832 value, int words = 0)
 82    {
 12504683        if (words == 0) words = values.Length / signs.Length;
 7983084        Span<ulong> target = values.Slice(index * words, words);
 15966085        WideArithmetic.GetMagnitude(value, target); signs[index] = (sbyte)value.Sign;
 7983086    }
 87
 88    internal static void WriteGradient(in WideDirection3d first, in WideDirection3d second, Span<ulong> values, Span<sby
 89    {
 40590        values.Clear();
 40591        int words = values.Length / signs.Length;
 324092        for (int component = 0; component < 3; component++)
 93        {
 243094            Signed576 a = Component(first, component), b = Component(second, component);
 121595            WideArithmetic.GetMagnitude(a, values.Slice(component * 2 * words, words));
 121596            WideArithmetic.GetMagnitude(b, values.Slice((component * 2 + 1) * words, words));
 243097            signs[component * 2] = (sbyte)a.Sign; signs[component * 2 + 1] = (sbyte)b.Sign;
 98        }
 40599    }
 100
 101    [MethodImpl(MethodImplOptions.NoInlining)]
 102    internal static void BuildValues(in WideDirection3d edge, in WideDirection3d offset, Signed576 radius, int valueShif
 103        Span<ulong> values, Span<sbyte> signs, bool useRigidBounds = false)
 104    {
 247105        if (useRigidBounds)
 106        {
 109107            BuildValues(GetRigidAxis(edge), GetRigidAxis(offset), Signed320.NarrowValue(radius), valueShift, values, sig
 109108            return;
 109        }
 138110        int words = values.Length / signs.Length;
 276111        Span<ulong> invariants = stackalloc ulong[8 * words]; Span<sbyte> invariantSigns = stackalloc sbyte[8];
 276112        invariants.Clear(); invariantSigns.Clear();
 138113        Write(invariants, invariantSigns, 0, Signed832.ExtendValue(Signed192.Signed(1)), words);
 138114        Write(invariants, invariantSigns, 1, edge.SquaredLength, words);
 138115        Write(invariants, invariantSigns, 2, Signed832.ExtendValue(edge.Y), words);
 138116        Write(invariants, invariantSigns, 3, offset.SquaredLength, words);
 138117        Write(invariants, invariantSigns, 4, Signed832.ExtendValue(offset.Y), words);
 138118        Write(invariants, invariantSigns, 5, WideDirection3d.Dot(edge, offset), words);
 138119        Write(invariants, invariantSigns, 6, WideArithmetic.MultiplySigned576ToSigned832(radius, radius), words);
 138120        CylinderPairSideValuePolynomial.BuildUnshifted(invariants, invariantSigns, words, values, signs);
 138121        WideFiniteAxisIntersection.ScaleFiniteAxisPolynomialVariable(values, 5, valueShift);
 138122        WideFiniteAxisIntersection.NormalizeFiniteAxisPolynomialPowerOfTwo(values, signs);
 138123    }
 124
 125    /// <summary>
 126    /// Tests whether the radial support point projects within a finite segment.
 127    /// halfAxis must be a positive multiple of axis; radius and Q are positive,
 128    /// Q=radius²|first_h+t*second_h|². Scratch needs seven disjoint forty-word
 129    /// slots and must not overlap root or Q. No stationarity is assumed here.
 130    /// Axis/chart components are below 2^198; offset/halfAxis/radius below 2^232,
 131    /// following the shared circular chart bounds.
 132    /// </summary>
 133    [MethodImpl(MethodImplOptions.NoInlining)]
 134    internal static bool HasSegmentSupport(WideAxis3 axis, WideAxis3 halfAxis, WideAxis3 offset,
 135        Signed320 radius, WideAxis3 first, WideAxis3 second, scoped ref FiniteAxisValueRoot root,
 136        ReadOnlySpan<ulong> q, ReadOnlySpan<sbyte> qSigns, Span<ulong> scratch)
 137    {
 138        // lambda=a+T/sqrt(Q), H=axis.halfAxis>0. All terms use the same
 139        // coordinate scale, which cancels from -H<=lambda<=H. Do not use the
 140        // independently normalized stationary/value polynomials in place of Q.
 112141        Signed576 a = WideAxis3.Dot(axis, offset), h = WideAxis3.Dot(axis, halfAxis);
 112142        Span<ulong> t = scratch[..(2 * Words)], quadratic = scratch.Slice(2 * Words, 3 * Words);
 112143        Span<ulong> square = Slot(scratch, 5), product = Slot(scratch, 6);
 112144        Span<sbyte> tSigns = stackalloc sbyte[2], quadraticSigns = stackalloc sbyte[3];
 56145        Write(t, tSigns, 0, RadialDot(axis, first));
 56146        Write(t, tSigns, 1, RadialDot(axis, second));
 56147        Import(WideArithmetic.MultiplySigned320(radius, radius), square);
 336148        for (int index = 0; index < 2; index++)
 149        {
 112150            WideArithmetic.MultiplyMagnitudes(Slot(t, index), square, product);
 112151            product.CopyTo(Slot(t, index));
 152        }
 56153        int tSign = WideFiniteAxisIntersection.GetSignAtFiniteValueRootAndRefine(ref root, t, tSigns);
 312154        for (int bound = 0; bound < 2; bound++)
 155        {
 108156            Signed576 b = bound == 0 ? WideArithmetic.AddSigned576(a, h) : WideArithmetic.SubtractSigned576(a, h);
 157            int sign;
 117158            if (tSign == 0) sign = b.Sign;
 134159            else if (b.Sign == 0 || b.Sign == tSign) sign = tSign;
 160            else
 161            {
 162                // Opposite unsquared signs: sign(T+b*sqrt(Q)) is
 163                // sign(T)*sign(T²-b²Q), including exact equality. Equal signs
 164                // must be handled first; squaring them would admit false support.
 64165                WideFiniteAxisIntersection.MultiplyFiniteAxisPolynomials(t, tSigns, t, tSigns,
 64166                    quadratic, quadraticSigns, product);
 64167                Import(b, square);
 64168                WideArithmetic.MultiplyMagnitudes(square, square, product);
 64169                product.CopyTo(square);
 512170                for (int index = 0; index < 3; index++)
 171                {
 192172                    WideArithmetic.MultiplyMagnitudes(Slot(q, index), square, product);
 192173                    int coefficientSign = quadraticSigns[index];
 192174                    Add(product, -qSigns[index], Slot(quadratic, index), ref coefficientSign);
 192175                    quadraticSigns[index] = (sbyte)coefficientSign;
 176                }
 64177                sign = tSign * WideFiniteAxisIntersection.GetSignAtFiniteValueRootAndRefine(ref root, quadratic, quadrat
 178            }
 116179            if (bound == 0 ? sign < 0 : sign > 0) return false;
 180        }
 181        // a,H<2^432; T<2^861; comparison coefficients<2^1723 under the
 182        // shared chart bounds. Forty-word arithmetic needs no wider owner.
 48183        return true;
 184    }
 185
 186    [MethodImpl(MethodImplOptions.NoInlining)]
 187    internal static void BuildParameter(in WideAxis3 offset, Signed320 radius, Signed192 rawScale,
 188        in WideAxis3 first, in WideAxis3 second, Span<ulong> data, Span<sbyte> signs)
 189    {
 190        // Shifted core-region coordinates are <2^232 but chart directions
 191        // retain original edges (<2^198), never scaled vertex differences.
 192        // M<2^398,P<2^432,Q<2^852,K<2^832,L<2^1252,W<2^2520,
 193        // N<2^2534,D<2^2396. Forty words give 2560 bits for either region.
 8792194        Span<ulong> inputs = stackalloc ulong[11 * Words];
 8792195        Span<sbyte> inputSigns = stackalloc sbyte[9];
 17584196        inputs.Clear(); inputSigns.Clear();
 17584197        Span<ulong> p = inputs[..(2 * Words)], q = inputs.Slice(2 * Words, 3 * Words);
 17584198        Span<ulong> metric = inputs.Slice(5 * Words, 3 * Words), scale = Slot(inputs, 8);
 17584199        Span<ulong> radiusSquared = Slot(inputs, 9), product = Slot(inputs, 10);
 8792200        Write(p, inputSigns[..2], 0, WideAxis3.Dot(offset, first));
 8792201        Write(p, inputSigns[..2], 1, WideAxis3.Dot(offset, second));
 8792202        Write(metric, inputSigns.Slice(5, 3), 0, first.SquaredLength);
 8792203        Write(metric, inputSigns.Slice(5, 3), 1, Twice(WideAxis3.Dot(first, second)));
 8792204        Write(metric, inputSigns.Slice(5, 3), 2, second.SquaredLength);
 8792205        Write(q, inputSigns.Slice(2, 3), 0, RadialDot(first, first));
 8792206        Write(q, inputSigns.Slice(2, 3), 1, Twice(RadialDot(first, second)));
 8792207        Write(q, inputSigns.Slice(2, 3), 2, RadialDot(second, second));
 8792208        Import(WideArithmetic.MultiplySigned320(radius, radius), radiusSquared);
 70336209        for (int index = 0; index < 3; index++)
 210        {
 26376211            WideArithmetic.MultiplyMagnitudes(Slot(q, index), radiusSquared, product);
 26376212            product.CopyTo(Slot(q, index));
 213        }
 8792214        Import(Signed320.ExtendValue(rawScale), scale);
 8792215        CylinderEdgeContactPolynomial.Build(p, inputSigns[..2], q, inputSigns.Slice(2, 3),
 8792216            metric, inputSigns.Slice(5, 3), scale, data[..(26 * Words)], signs[..26]);
 217
 8792218    }
 219
 220    /// <summary>
 221    /// Reuses a built chart for the swapped basis (second+s*first). Only the
 222    /// 26 shared coefficient slots are changed; caller admission slots remain intact.
 223    /// </summary>
 224    internal static void ReverseParameterChart(Span<ulong> data, Span<sbyte> signs)
 225    {
 226        // t=1/s gives Pbar=s*P(1/s), Qbar=s²*Q(1/s), Mbar=s²*M(1/s).
 227        // Kbar=-s*K(1/s), Lbar=-s²*L(1/s), Jbar=-s²*J(1/s).
 228        // W, N and D reverse as quartics. Fixed nominal degrees retain zero
 229        // ends, and reversal preserves W's and N/D's power-of-two normalization.
 7147230        ReverseCoefficients(data, signs, 0, 5);
 7147231        ReverseCoefficients(data, signs, 5, 3);
 7147232        ReverseCoefficients(data, signs, 8, 2);
 7147233        ReverseCoefficients(data, signs, 10, 3);
 7147234        ReverseCoefficients(data, signs, 13, 3);
 7147235        ReverseCoefficients(data, signs, 16, 5);
 7147236        ReverseCoefficients(data, signs, 21, 5);
 185822237        for (int index = 8; index < 16; index++) signs[index] = (sbyte)-signs[index];
 7147238    }
 239
 240    private static void ReverseCoefficients(Span<ulong> data, Span<sbyte> signs, int start, int count)
 241    {
 50029242        int words = data.Length / signs.Length;
 50029243        signs.Slice(start, count).Reverse();
 242998244        for (int index = 0; index < count / 2; index++)
 245        {
 71470246            Span<ulong> first = data.Slice((start + index) * words, words),
 71470247                second = data.Slice((start + count - 1 - index) * words, words);
 7538140248            for (int word = 0; word < words; word++)
 3697600249                (first[word], second[word]) = (second[word], first[word]);
 250        }
 50029251    }
 252
 253    [MethodImpl(MethodImplOptions.NoInlining)]
 254    internal static void BuildValues(in WideAxis3 e, in WideAxis3 c, Signed320 radius, int valueShift,
 255        Span<ulong> values, Span<sbyte> signs)
 256    {
 161257        Span<ulong> invariants = stackalloc ulong[8 * ValueWords];
 161258        Span<sbyte> invariantSigns = stackalloc sbyte[8];
 322259        invariants.Clear(); invariantSigns.Clear();
 161260        Write(invariants, invariantSigns, 0, Signed576.ExtendValue(Signed320.ExtendValue(Signed192.Signed(1))), ValueWor
 161261        Write(invariants, invariantSigns, 1, e.SquaredLength, ValueWords);
 161262        Write(invariants, invariantSigns, 2, Signed576.ExtendValue(e.Y), ValueWords);
 161263        Write(invariants, invariantSigns, 3, c.SquaredLength, ValueWords);
 161264        Write(invariants, invariantSigns, 4, Signed576.ExtendValue(c.Y), ValueWords);
 161265        Write(invariants, invariantSigns, 5, WideAxis3.Dot(e, c), ValueWords);
 161266        Write(invariants, invariantSigns, 6, WideArithmetic.MultiplySigned320(radius, radius), ValueWords);
 161267        CylinderPairSideValuePolynomial.BuildUnshifted(invariants, invariantSigns, ValueWords, values, signs);
 268        // Retained edges keep B<398,C<198 bits; shifted c gives q<466,
 269        // x<232,y<432,rho<454. At ValueShift<=472, weighted linear
 270        // invariant heights are <872. Quartic convolutions including their
 271        // carries stay below 3500 bits, inside 56 words (3584 bits).
 161272        WideFiniteAxisIntersection.ScaleFiniteAxisPolynomialVariable(values, 5, valueShift);
 161273        WideFiniteAxisIntersection.NormalizeFiniteAxisPolynomialPowerOfTwo(values, signs);
 161274    }
 275
 276    internal static void GetBasis(WideAxis3 edge, out WideAxis3 first, out WideAxis3 second)
 277    {
 120278        if (!edge.X.IsZero)
 279        {
 118280            first = new WideAxis3(WideArithmetic.Negate(edge.Y), edge.X, default);
 118281            second = new WideAxis3(WideArithmetic.Negate(edge.Z), default, edge.X);
 282        }
 283        else
 284        {
 2285            first = new WideAxis3(default, WideArithmetic.Negate(edge.Z), edge.Y);
 2286            second = new WideAxis3(edge.Y, default, default);
 287        }
 2288    }
 289
 290    internal static void WriteGradient(WideAxis3 first, WideAxis3 second, Span<ulong> values, Span<sbyte> signs)
 291    {
 36292        values.Clear();
 288293        for (int component = 0; component < 3; component++)
 294        {
 216295            Signed320 a = Component(first, component), b = Component(second, component);
 216296            Span<ulong> firstSlot = values.Slice(component * 10, 5), secondSlot = values.Slice(component * 10 + 5, 5);
 108297            WideArithmetic.GetMagnitude(a, out firstSlot[4], out firstSlot[3], out firstSlot[2], out firstSlot[1], out f
 108298            WideArithmetic.GetMagnitude(b, out secondSlot[4], out secondSlot[3], out secondSlot[2], out secondSlot[1], o
 216299            signs[2 * component] = (sbyte)a.Sign; signs[2 * component + 1] = (sbyte)b.Sign;
 300        }
 36301    }
 72302    internal static WideAxis3 Transform(WideRationalBasis3d basis, WideAxis3 axis) => new(
 72303        TransformComponent(basis.Xx, basis.Yx, basis.Zx, axis),
 72304        TransformComponent(basis.Xy, basis.Yy, basis.Zy, axis),
 72305        TransformComponent(basis.Xz, basis.Yz, basis.Zz, axis));
 306    internal static Signed320 TransformComponent(Signed192 x, Signed192 y, Signed192 z, WideAxis3 axis) =>
 216307        Signed320.NarrowValue(WideAxis3.Dot(new WideAxis3(Signed320.ExtendValue(x), Signed320.ExtendValue(y), Signed320.
 26690308    internal static Signed576 RadialDot(in WideAxis3 a, in WideAxis3 b) => WideArithmetic.AddSigned576(
 26690309        WideArithmetic.MultiplySigned320(a.X, b.X), WideArithmetic.MultiplySigned320(a.Z, b.Z));
 17584310    internal static Signed576 Twice(Signed576 value) => WideArithmetic.AddSigned576(value, value);
 311    internal static int Sign(ref FiniteAxisValueRoot root, ReadOnlySpan<ulong> data, ReadOnlySpan<sbyte> signs, int star
 28250312        WideFiniteAxisIntersection.GetSignAtFiniteValueRootAndRefine(ref root,
 28250313            data.Slice(start * (data.Length / signs.Length), count * (data.Length / signs.Length)), signs.Slice(start, c
 314    internal static void Write(Span<ulong> values, Span<sbyte> signs, int index, Signed576 value, int words = Words)
 315    {
 71575316        Span<ulong> target = values.Slice(index * words, words);
 214725317        target.Clear(); WideArithmetic.GetMagnitude(value, target[..9]); signs[index] = (sbyte)value.Sign;
 71575318    }
 319}
Generated by: ReportGenerator 5.5.12.0
11/04/2026 - 16:26:30
GitHub | reportgenerator.io

Methods/Properties

BuildParameter(FixedMathSharp.Geometry.WideDirection3d&,FixedMathSharp.Signed576,FixedMathSharp.Signed320,FixedMathSharp.Geometry.WideDirection3d&,FixedMathSharp.Geometry.WideDirection3d&,System.Span`1<System.UInt64>,System.Span`1<System.SByte>,System.Boolean)
GetRigidAxis(FixedMathSharp.Geometry.WideDirection3d&)
GetBasis(FixedMathSharp.Geometry.WideDirection3d&,FixedMathSharp.Geometry.WideDirection3d&,FixedMathSharp.Geometry.WideDirection3d&)
Transform(FixedMathSharp.Geometry.WideRationalBasis3d&,FixedMathSharp.Geometry.WideDirection3d&)
RadialDot(FixedMathSharp.Geometry.WideDirection3d&,FixedMathSharp.Geometry.WideDirection3d&)
Twice(FixedMathSharp.Signed832)
Write(System.Span`1<System.UInt64>,System.Span`1<System.SByte>,System.Int32,FixedMathSharp.Signed832,System.Int32)
WriteGradient(FixedMathSharp.Geometry.WideDirection3d&,FixedMathSharp.Geometry.WideDirection3d&,System.Span`1<System.UInt64>,System.Span`1<System.SByte>)
BuildValues(FixedMathSharp.Geometry.WideDirection3d&,FixedMathSharp.Geometry.WideDirection3d&,FixedMathSharp.Signed576,System.Int32,System.Span`1<System.UInt64>,System.Span`1<System.SByte>,System.Boolean)
HasSegmentSupport(FixedMathSharp.Geometry.WideAxis3,FixedMathSharp.Geometry.WideAxis3,FixedMathSharp.Geometry.WideAxis3,FixedMathSharp.Signed320,FixedMathSharp.Geometry.WideAxis3,FixedMathSharp.Geometry.WideAxis3,FixedMathSharp.Geometry.FiniteAxisValueRoot&,System.ReadOnlySpan`1<System.UInt64>,System.ReadOnlySpan`1<System.SByte>,System.Span`1<System.UInt64>)
BuildParameter(FixedMathSharp.Geometry.WideAxis3&,FixedMathSharp.Signed320,FixedMathSharp.Signed192,FixedMathSharp.Geometry.WideAxis3&,FixedMathSharp.Geometry.WideAxis3&,System.Span`1<System.UInt64>,System.Span`1<System.SByte>)
ReverseParameterChart(System.Span`1<System.UInt64>,System.Span`1<System.SByte>)
ReverseCoefficients(System.Span`1<System.UInt64>,System.Span`1<System.SByte>,System.Int32,System.Int32)
BuildValues(FixedMathSharp.Geometry.WideAxis3&,FixedMathSharp.Geometry.WideAxis3&,FixedMathSharp.Signed320,System.Int32,System.Span`1<System.UInt64>,System.Span`1<System.SByte>)
GetBasis(FixedMathSharp.Geometry.WideAxis3,FixedMathSharp.Geometry.WideAxis3&,FixedMathSharp.Geometry.WideAxis3&)
WriteGradient(FixedMathSharp.Geometry.WideAxis3,FixedMathSharp.Geometry.WideAxis3,System.Span`1<System.UInt64>,System.Span`1<System.SByte>)
Transform(FixedMathSharp.Geometry.WideRationalBasis3d,FixedMathSharp.Geometry.WideAxis3)
TransformComponent(FixedMathSharp.Signed192,FixedMathSharp.Signed192,FixedMathSharp.Signed192,FixedMathSharp.Geometry.WideAxis3)
RadialDot(FixedMathSharp.Geometry.WideAxis3&,FixedMathSharp.Geometry.WideAxis3&)
Twice(FixedMathSharp.Signed576)
Sign(FixedMathSharp.Geometry.FiniteAxisValueRoot&,System.ReadOnlySpan`1<System.UInt64>,System.ReadOnlySpan`1<System.SByte>,System.Int32,System.Int32)
Write(System.Span`1<System.UInt64>,System.Span`1<System.SByte>,System.Int32,FixedMathSharp.Signed576,System.Int32)