Skip to content

Commit 0c6d412

Browse files
tannergoodingtannergooding
authored
Iterative generic math changes to match API review (#69391)
* Change GetShortestBitLength to return int and add WriteBigEndian APIs * Add WriteExponentBigEndian and WriteSignificandBigEndian APIs * Update System.Char to explicitly implement the numeric interfaces * Ensure BigInteger.TryWriteBigEndian correctly offsets the address * Fixing two usages of `var` in decimal * Ensure lo64 is ulong and hi32 is uint * Ensure Int128/UInt128 implement TryWriteBigEndian and return `int` for `GetShortestBitLength` * Ensure that `GetByteCount` and `GetShortestBitLength` correctly handle the one's complement format * Ensure the ReverseEndianness calls in TryWrite* for Int128/UInt128 are correct * Ensure BigInteger.TryWriteLittleEndian has a correct assert
1 parent 7bb207c commit 0c6d412

45 files changed

Lines changed: 2510 additions & 273 deletions

Some content is hidden

Large Commits have some content hidden by default. Use the searchbox below for content that may be hidden.

‎src/libraries/Common/tests/System/GenericMathHelpers.cs‎

Lines changed: 12 additions & 6 deletions
Original file line numberDiff line numberDiff line change
@@ -25,10 +25,6 @@ public static class BinaryIntegerHelper<TSelf>
2525
{
2626
public static (TSelf Quotient, TSelf Remainder) DivRem(TSelf left, TSelf right) => TSelf.DivRem(left, right);
2727

28-
public static int GetByteCount(TSelf value) => value.GetByteCount();
29-
30-
public static long GetShortestBitLength(TSelf value) => value.GetShortestBitLength();
31-
3228
public static TSelf LeadingZeroCount(TSelf value) => TSelf.LeadingZeroCount(value);
3329

3430
public static TSelf PopCount(TSelf value) => TSelf.PopCount(value);
@@ -39,6 +35,12 @@ public static class BinaryIntegerHelper<TSelf>
3935

4036
public static TSelf TrailingZeroCount(TSelf value) => TSelf.TrailingZeroCount(value);
4137

38+
public static int GetByteCount(TSelf value) => value.GetByteCount();
39+
40+
public static int GetShortestBitLength(TSelf value) => value.GetShortestBitLength();
41+
42+
public static bool TryWriteBigEndian(TSelf value, Span<byte> destination, out int bytesWritten) => value.TryWriteBigEndian(destination, out bytesWritten);
43+
4244
public static bool TryWriteLittleEndian(TSelf value, Span<byte> destination, out int bytesWritten) => value.TryWriteLittleEndian(destination, out bytesWritten);
4345
}
4446

@@ -103,14 +105,18 @@ public static class FloatingPointHelper<TSelf>
103105
{
104106
public static int GetExponentByteCount(TSelf value) => value.GetExponentByteCount();
105107

106-
public static long GetExponentShortestBitLength(TSelf value) => value.GetExponentShortestBitLength();
108+
public static int GetExponentShortestBitLength(TSelf value) => value.GetExponentShortestBitLength();
107109

108110
public static int GetSignificandByteCount(TSelf value) => value.GetSignificandByteCount();
109111

110-
public static long GetSignificandBitLength(TSelf value) => value.GetSignificandBitLength();
112+
public static int GetSignificandBitLength(TSelf value) => value.GetSignificandBitLength();
113+
114+
public static bool TryWriteExponentBigEndian(TSelf value, Span<byte> destination, out int bytesWritten) => value.TryWriteExponentBigEndian(destination, out bytesWritten);
111115

112116
public static bool TryWriteExponentLittleEndian(TSelf value, Span<byte> destination, out int bytesWritten) => value.TryWriteExponentLittleEndian(destination, out bytesWritten);
113117

118+
public static bool TryWriteSignificandBigEndian(TSelf value, Span<byte> destination, out int bytesWritten) => value.TryWriteSignificandBigEndian(destination, out bytesWritten);
119+
114120
public static bool TryWriteSignificandLittleEndian(TSelf value, Span<byte> destination, out int bytesWritten) => value.TryWriteSignificandLittleEndian(destination, out bytesWritten);
115121
}
116122

‎src/libraries/System.Private.CoreLib/src/System/Byte.cs‎

Lines changed: 19 additions & 1 deletion
Original file line numberDiff line numberDiff line change
@@ -333,11 +333,29 @@ object IConvertible.ToType(Type type, IFormatProvider? provider)
333333
public static byte TrailingZeroCount(byte value) => (byte)(BitOperations.TrailingZeroCount(value << 24) - 24);
334334

335335
/// <inheritdoc cref="IBinaryInteger{TSelf}.GetShortestBitLength()" />
336-
long IBinaryInteger<byte>.GetShortestBitLength() => (sizeof(byte) * 8) - LeadingZeroCount(m_value);
336+
int IBinaryInteger<byte>.GetShortestBitLength() => (sizeof(byte) * 8) - LeadingZeroCount(m_value);
337337

338338
/// <inheritdoc cref="IBinaryInteger{TSelf}.GetByteCount()" />
339339
int IBinaryInteger<byte>.GetByteCount() => sizeof(byte);
340340

341+
/// <inheritdoc cref="IBinaryInteger{TSelf}.TryWriteBigEndian(Span{byte}, out int)" />
342+
bool IBinaryInteger<byte>.TryWriteBigEndian(Span<byte> destination, out int bytesWritten)
343+
{
344+
if (destination.Length >= sizeof(byte))
345+
{
346+
byte value = m_value;
347+
Unsafe.WriteUnaligned(ref MemoryMarshal.GetReference(destination), value);
348+
349+
bytesWritten = sizeof(byte);
350+
return true;
351+
}
352+
else
353+
{
354+
bytesWritten = 0;
355+
return false;
356+
}
357+
}
358+
341359
/// <inheritdoc cref="IBinaryInteger{TSelf}.TryWriteLittleEndian(Span{byte}, out int)" />
342360
bool IBinaryInteger<byte>.TryWriteLittleEndian(Span<byte> destination, out int bytesWritten)
343361
{

‎src/libraries/System.Private.CoreLib/src/System/Char.cs‎

Lines changed: 37 additions & 23 deletions
Original file line numberDiff line numberDiff line change
@@ -1166,29 +1166,47 @@ public static int ConvertToUtf32(string s, int index)
11661166
//
11671167

11681168
/// <inheritdoc cref="IBinaryInteger{TSelf}.DivRem(TSelf, TSelf)" />
1169-
public static (char Quotient, char Remainder) DivRem(char left, char right) => ((char, char))Math.DivRem(left, right);
1169+
static (char Quotient, char Remainder) IBinaryInteger<char>.DivRem(char left, char right) => ((char, char))Math.DivRem(left, right);
11701170

11711171
/// <inheritdoc cref="IBinaryInteger{TSelf}.LeadingZeroCount(TSelf)" />
1172-
public static char LeadingZeroCount(char value) => (char)(BitOperations.LeadingZeroCount(value) - 16);
1172+
static char IBinaryInteger<char>.LeadingZeroCount(char value) => (char)(BitOperations.LeadingZeroCount(value) - 16);
11731173

11741174
/// <inheritdoc cref="IBinaryInteger{TSelf}.PopCount(TSelf)" />
1175-
public static char PopCount(char value) => (char)BitOperations.PopCount(value);
1175+
static char IBinaryInteger<char>.PopCount(char value) => (char)BitOperations.PopCount(value);
11761176

11771177
/// <inheritdoc cref="IBinaryInteger{TSelf}.RotateLeft(TSelf, int)" />
1178-
public static char RotateLeft(char value, int rotateAmount) => (char)((value << (rotateAmount & 15)) | (value >> ((16 - rotateAmount) & 15)));
1178+
static char IBinaryInteger<char>.RotateLeft(char value, int rotateAmount) => (char)((value << (rotateAmount & 15)) | (value >> ((16 - rotateAmount) & 15)));
11791179

11801180
/// <inheritdoc cref="IBinaryInteger{TSelf}.RotateRight(TSelf, int)" />
1181-
public static char RotateRight(char value, int rotateAmount) => (char)((value >> (rotateAmount & 15)) | (value << ((16 - rotateAmount) & 15)));
1181+
static char IBinaryInteger<char>.RotateRight(char value, int rotateAmount) => (char)((value >> (rotateAmount & 15)) | (value << ((16 - rotateAmount) & 15)));
11821182

11831183
/// <inheritdoc cref="IBinaryInteger{TSelf}.TrailingZeroCount(TSelf)" />
1184-
public static char TrailingZeroCount(char value) => (char)(BitOperations.TrailingZeroCount(value << 16) - 16);
1184+
static char IBinaryInteger<char>.TrailingZeroCount(char value) => (char)(BitOperations.TrailingZeroCount(value << 16) - 16);
11851185

11861186
/// <inheritdoc cref="IBinaryInteger{TSelf}.GetShortestBitLength()" />
1187-
long IBinaryInteger<char>.GetShortestBitLength() => (sizeof(char) * 8) - LeadingZeroCount(m_value);
1187+
int IBinaryInteger<char>.GetShortestBitLength() => (sizeof(char) * 8) - ushort.LeadingZeroCount(m_value);
11881188

11891189
/// <inheritdoc cref="IBinaryInteger{TSelf}.GetByteCount()" />
11901190
int IBinaryInteger<char>.GetByteCount() => sizeof(char);
11911191

1192+
/// <inheritdoc cref="IBinaryInteger{TSelf}.TryWriteBigEndian(Span{byte}, out int)" />
1193+
bool IBinaryInteger<char>.TryWriteBigEndian(Span<byte> destination, out int bytesWritten)
1194+
{
1195+
if (destination.Length >= sizeof(char))
1196+
{
1197+
ushort value = BitConverter.IsLittleEndian ? BinaryPrimitives.ReverseEndianness(m_value) : m_value;
1198+
Unsafe.WriteUnaligned(ref MemoryMarshal.GetReference(destination), value);
1199+
1200+
bytesWritten = sizeof(char);
1201+
return true;
1202+
}
1203+
else
1204+
{
1205+
bytesWritten = 0;
1206+
return false;
1207+
}
1208+
}
1209+
11921210
/// <inheritdoc cref="IBinaryInteger{TSelf}.TryWriteLittleEndian(Span{byte}, out int)" />
11931211
bool IBinaryInteger<char>.TryWriteLittleEndian(Span<byte> destination, out int bytesWritten)
11941212
{
@@ -1212,10 +1230,10 @@ bool IBinaryInteger<char>.TryWriteLittleEndian(Span<byte> destination, out int b
12121230
//
12131231

12141232
/// <inheritdoc cref="IBinaryNumber{TSelf}.IsPow2(TSelf)" />
1215-
public static bool IsPow2(char value) => BitOperations.IsPow2((uint)value);
1233+
static bool IBinaryNumber<char>.IsPow2(char value) => ushort.IsPow2(value);
12161234

12171235
/// <inheritdoc cref="IBinaryNumber{TSelf}.Log2(TSelf)" />
1218-
public static char Log2(char value) => (char)BitOperations.Log2(value);
1236+
static char IBinaryNumber<char>.Log2(char value) => (char)(ushort.Log2(value));
12191237

12201238
//
12211239
// IBitwiseOperators
@@ -1331,15 +1349,14 @@ bool IBinaryInteger<char>.TryWriteLittleEndian(Span<byte> destination, out int b
13311349
static char INumber<char>.Abs(char value) => value;
13321350

13331351
/// <inheritdoc cref="INumber{TSelf}.Clamp(TSelf, TSelf, TSelf)" />
1334-
public static char Clamp(char value, char min, char max) => (char)Math.Clamp(value, min, max);
1352+
static char INumber<char>.Clamp(char value, char min, char max) => (char)Math.Clamp(value, min, max);
13351353

13361354
/// <inheritdoc cref="INumber{TSelf}.CopySign(TSelf, TSelf)" />
13371355
static char INumber<char>.CopySign(char value, char sign) => value;
13381356

13391357
/// <inheritdoc cref="INumber{TSelf}.CreateChecked{TOther}(TOther)" />
13401358
[MethodImpl(MethodImplOptions.AggressiveInlining)]
1341-
public static char CreateChecked<TOther>(TOther value)
1342-
where TOther : INumber<TOther>
1359+
static char INumber<char>.CreateChecked<TOther>(TOther value)
13431360
{
13441361
if (typeof(TOther) == typeof(byte))
13451362
{
@@ -1406,8 +1423,7 @@ public static char CreateChecked<TOther>(TOther value)
14061423

14071424
/// <inheritdoc cref="INumber{TSelf}.CreateSaturating{TOther}(TOther)" />
14081425
[MethodImpl(MethodImplOptions.AggressiveInlining)]
1409-
public static char CreateSaturating<TOther>(TOther value)
1410-
where TOther : INumber<TOther>
1426+
static char INumber<char>.CreateSaturating<TOther>(TOther value)
14111427
{
14121428
if (typeof(TOther) == typeof(byte))
14131429
{
@@ -1491,8 +1507,7 @@ public static char CreateSaturating<TOther>(TOther value)
14911507

14921508
/// <inheritdoc cref="INumber{TSelf}.CreateTruncating{TOther}(TOther)" />
14931509
[MethodImpl(MethodImplOptions.AggressiveInlining)]
1494-
public static char CreateTruncating<TOther>(TOther value)
1495-
where TOther : INumber<TOther>
1510+
static char INumber<char>.CreateTruncating<TOther>(TOther value)
14961511
{
14971512
if (typeof(TOther) == typeof(byte))
14981513
{
@@ -1561,24 +1576,23 @@ public static char CreateTruncating<TOther>(TOther value)
15611576
static bool INumber<char>.IsNegative(char value) => false;
15621577

15631578
/// <inheritdoc cref="INumber{TSelf}.Max(TSelf, TSelf)" />
1564-
public static char Max(char x, char y) => (char)Math.Max(x, y);
1579+
static char INumber<char>.Max(char x, char y) => (char)Math.Max(x, y);
15651580

15661581
/// <inheritdoc cref="INumber{TSelf}.MaxMagnitude(TSelf, TSelf)" />
1567-
static char INumber<char>.MaxMagnitude(char x, char y) => Max(x, y);
1582+
static char INumber<char>.MaxMagnitude(char x, char y) => (char)Math.Max(x, y);
15681583

15691584
/// <inheritdoc cref="INumber{TSelf}.Min(TSelf, TSelf)" />
1570-
public static char Min(char x, char y) => (char)Math.Min(x, y);
1585+
static char INumber<char>.Min(char x, char y) => (char)Math.Min(x, y);
15711586

15721587
/// <inheritdoc cref="INumber{TSelf}.MinMagnitude(TSelf, TSelf)" />
1573-
static char INumber<char>.MinMagnitude(char x, char y) => Min(x, y);
1588+
static char INumber<char>.MinMagnitude(char x, char y) => (char)Math.Min(x, y);
15741589

15751590
/// <inheritdoc cref="INumber{TSelf}.Sign(TSelf)" />
1576-
public static int Sign(char value) => (value == 0) ? 0 : 1;
1591+
static int INumber<char>.Sign(char value) => (value == 0) ? 0 : 1;
15771592

15781593
/// <inheritdoc cref="INumber{TSelf}.TryCreate{TOther}(TOther, out TSelf)" />
15791594
[MethodImpl(MethodImplOptions.AggressiveInlining)]
1580-
public static bool TryCreate<TOther>(TOther value, out char result)
1581-
where TOther : INumber<TOther>
1595+
static bool INumber<char>.TryCreate<TOther>(TOther value, out char result)
15821596
{
15831597
if (typeof(TOther) == typeof(byte))
15841598
{

‎src/libraries/System.Private.CoreLib/src/System/Decimal.cs‎

Lines changed: 56 additions & 9 deletions
Original file line numberDiff line numberDiff line change
@@ -1150,15 +1150,39 @@ object IConvertible.ToType(Type type, IFormatProvider? provider)
11501150
// IFloatingPoint
11511151
//
11521152

1153+
/// <inheritdoc cref="IFloatingPoint{TSelf}.GetExponentByteCount()" />
1154+
int IFloatingPoint<decimal>.GetExponentByteCount() => sizeof(sbyte);
1155+
11531156
/// <inheritdoc cref="IFloatingPoint{TSelf}.GetExponentShortestBitLength()" />
1154-
long IFloatingPoint<decimal>.GetExponentShortestBitLength()
1157+
int IFloatingPoint<decimal>.GetExponentShortestBitLength()
11551158
{
11561159
sbyte exponent = Exponent;
11571160
return (sizeof(sbyte) * 8) - sbyte.LeadingZeroCount(exponent);
11581161
}
11591162

1160-
/// <inheritdoc cref="IFloatingPoint{TSelf}.GetExponentByteCount()" />
1161-
int IFloatingPoint<decimal>.GetExponentByteCount() => sizeof(sbyte);
1163+
/// <inheritdoc cref="IFloatingPoint{TSelf}.GetSignificandByteCount()" />
1164+
int IFloatingPoint<decimal>.GetSignificandByteCount() => sizeof(ulong) + sizeof(uint);
1165+
1166+
/// <inheritdoc cref="IFloatingPoint{TSelf}.GetSignificandBitLength()" />
1167+
int IFloatingPoint<decimal>.GetSignificandBitLength() => 96;
1168+
1169+
/// <inheritdoc cref="IFloatingPoint{TSelf}.TryWriteExponentBigEndian(Span{byte}, out int)" />
1170+
bool IFloatingPoint<decimal>.TryWriteExponentBigEndian(Span<byte> destination, out int bytesWritten)
1171+
{
1172+
if (destination.Length >= sizeof(sbyte))
1173+
{
1174+
sbyte exponent = Exponent;
1175+
Unsafe.WriteUnaligned(ref MemoryMarshal.GetReference(destination), exponent);
1176+
1177+
bytesWritten = sizeof(sbyte);
1178+
return true;
1179+
}
1180+
else
1181+
{
1182+
bytesWritten = 0;
1183+
return false;
1184+
}
1185+
}
11621186

11631187
/// <inheritdoc cref="IFloatingPoint{TSelf}.TryWriteExponentLittleEndian(Span{byte}, out int)" />
11641188
bool IFloatingPoint<decimal>.TryWriteExponentLittleEndian(Span<byte> destination, out int bytesWritten)
@@ -1178,19 +1202,42 @@ bool IFloatingPoint<decimal>.TryWriteExponentLittleEndian(Span<byte> destination
11781202
}
11791203
}
11801204

1181-
/// <inheritdoc cref="IFloatingPoint{TSelf}.GetSignificandBitLength()" />
1182-
long IFloatingPoint<decimal>.GetSignificandBitLength() => 96;
1205+
/// <inheritdoc cref="IFloatingPoint{TSelf}.TryWriteSignificandBigEndian(Span{byte}, out int)" />
1206+
bool IFloatingPoint<decimal>.TryWriteSignificandBigEndian(Span<byte> destination, out int bytesWritten)
1207+
{
1208+
if (destination.Length >= (sizeof(uint) + sizeof(ulong)))
1209+
{
1210+
uint hi32 = _hi32;
1211+
ulong lo64 = _lo64;
11831212

1184-
/// <inheritdoc cref="IFloatingPoint{TSelf}.GetSignificandByteCount()" />
1185-
int IFloatingPoint<decimal>.GetSignificandByteCount() => sizeof(ulong) + sizeof(uint);
1213+
if (BitConverter.IsLittleEndian)
1214+
{
1215+
hi32 = BinaryPrimitives.ReverseEndianness(hi32);
1216+
lo64 = BinaryPrimitives.ReverseEndianness(lo64);
1217+
}
1218+
1219+
ref byte address = ref MemoryMarshal.GetReference(destination);
1220+
1221+
Unsafe.WriteUnaligned(ref address, hi32);
1222+
Unsafe.WriteUnaligned(ref Unsafe.AddByteOffset(ref address, sizeof(uint)), lo64);
1223+
1224+
bytesWritten = sizeof(uint) + sizeof(ulong);
1225+
return true;
1226+
}
1227+
else
1228+
{
1229+
bytesWritten = 0;
1230+
return false;
1231+
}
1232+
}
11861233

11871234
/// <inheritdoc cref="IFloatingPoint{TSelf}.TryWriteSignificandLittleEndian(Span{byte}, out int)" />
11881235
bool IFloatingPoint<decimal>.TryWriteSignificandLittleEndian(Span<byte> destination, out int bytesWritten)
11891236
{
11901237
if (destination.Length >= (sizeof(ulong) + sizeof(uint)))
11911238
{
1192-
var lo64 = _lo64;
1193-
var hi32 = _hi32;
1239+
ulong lo64 = _lo64;
1240+
uint hi32 = _hi32;
11941241

11951242
if (!BitConverter.IsLittleEndian)
11961243
{

‎src/libraries/System.Private.CoreLib/src/System/Double.cs‎

Lines changed: 55 additions & 7 deletions
Original file line numberDiff line numberDiff line change
@@ -661,8 +661,11 @@ public static bool IsPow2(double value)
661661
/// <inheritdoc cref="IFloatingPoint{TSelf}.Truncate(TSelf)" />
662662
public static double Truncate(double x) => Math.Truncate(x);
663663

664+
/// <inheritdoc cref="IFloatingPoint{TSelf}.GetExponentByteCount()" />
665+
int IFloatingPoint<double>.GetExponentByteCount() => sizeof(short);
666+
664667
/// <inheritdoc cref="IFloatingPoint{TSelf}.GetExponentShortestBitLength()" />
665-
long IFloatingPoint<double>.GetExponentShortestBitLength()
668+
int IFloatingPoint<double>.GetExponentShortestBitLength()
666669
{
667670
short exponent = Exponent;
668671

@@ -676,8 +679,35 @@ long IFloatingPoint<double>.GetExponentShortestBitLength()
676679
}
677680
}
678681

679-
/// <inheritdoc cref="IFloatingPoint{TSelf}.GetExponentByteCount()" />
680-
int IFloatingPoint<double>.GetExponentByteCount() => sizeof(short);
682+
/// <inheritdoc cref="IFloatingPoint{TSelf}.GetSignificandByteCount()" />
683+
int IFloatingPoint<double>.GetSignificandByteCount() => sizeof(ulong);
684+
685+
/// <inheritdoc cref="IFloatingPoint{TSelf}.GetSignificandBitLength()" />
686+
int IFloatingPoint<double>.GetSignificandBitLength() => 53;
687+
688+
/// <inheritdoc cref="IFloatingPoint{TSelf}.TryWriteExponentBigEndian(Span{byte}, out int)" />
689+
bool IFloatingPoint<double>.TryWriteExponentBigEndian(Span<byte> destination, out int bytesWritten)
690+
{
691+
if (destination.Length >= sizeof(short))
692+
{
693+
short exponent = Exponent;
694+
695+
if (BitConverter.IsLittleEndian)
696+
{
697+
exponent = BinaryPrimitives.ReverseEndianness(exponent);
698+
}
699+
700+
Unsafe.WriteUnaligned(ref MemoryMarshal.GetReference(destination), exponent);
701+
702+
bytesWritten = sizeof(short);
703+
return true;
704+
}
705+
else
706+
{
707+
bytesWritten = 0;
708+
return false;
709+
}
710+
}
681711

682712
/// <inheritdoc cref="IFloatingPoint{TSelf}.TryWriteExponentLittleEndian(Span{byte}, out int)" />
683713
bool IFloatingPoint<double>.TryWriteExponentLittleEndian(Span<byte> destination, out int bytesWritten)
@@ -703,11 +733,29 @@ bool IFloatingPoint<double>.TryWriteExponentLittleEndian(Span<byte> destination,
703733
}
704734
}
705735

706-
/// <inheritdoc cref="IFloatingPoint{TSelf}.GetSignificandBitLength()" />
707-
long IFloatingPoint<double>.GetSignificandBitLength() => 53;
736+
/// <inheritdoc cref="IFloatingPoint{TSelf}.TryWriteSignificandBigEndian(Span{byte}, out int)" />
737+
bool IFloatingPoint<double>.TryWriteSignificandBigEndian(Span<byte> destination, out int bytesWritten)
738+
{
739+
if (destination.Length >= sizeof(ulong))
740+
{
741+
ulong significand = Significand;
708742

709-
/// <inheritdoc cref="IFloatingPoint{TSelf}.GetSignificandByteCount()" />
710-
int IFloatingPoint<double>.GetSignificandByteCount() => sizeof(ulong);
743+
if (BitConverter.IsLittleEndian)
744+
{
745+
significand = BinaryPrimitives.ReverseEndianness(significand);
746+
}
747+
748+
Unsafe.WriteUnaligned(ref MemoryMarshal.GetReference(destination), significand);
749+
750+
bytesWritten = sizeof(ulong);
751+
return true;
752+
}
753+
else
754+
{
755+
bytesWritten = 0;
756+
return false;
757+
}
758+
}
711759

712760
/// <inheritdoc cref="IFloatingPoint{TSelf}.TryWriteSignificandLittleEndian(Span{byte}, out int)" />
713761
bool IFloatingPoint<double>.TryWriteSignificandLittleEndian(Span<byte> destination, out int bytesWritten)

0 commit comments

Comments
 (0)