Skip to content
New issue

Have a question about this project? Sign up for a free GitHub account to open an issue and contact its maintainers and the community.

Sign up for GitHub

By clicking “Sign up for GitHub”, you agree to our terms of service and privacy statement. We’ll occasionally send you account related emails.

Already on GitHub? Sign in to your account

Jump to bottom

Revert "Minor cleanups for System.Runtime.Numerics (#53984)" #57297

Merged
merged 1 commit into from
Aug 12, 2021
Merged

Revert "Minor cleanups for System.Runtime.Numerics (#53984)" #57297

Show file tree
Hide file tree
Changes from all commits
Commits
Show all changes
1 commit
Select commit
File filter

Filter by extension

Filter by extension
Conversations
Failed to load comments.
Loading
Jump to
Jump to file
Failed to load files.
Loading
Diff view
Diff view
62 changes: 30 additions & 32 deletions src/libraries/System.Runtime.Numerics/src/System/Numerics/BigInteger.cs
View file
Open in desktop
Original file line number Diff line number Diff line change
Expand Up @@ -4,7 +4,6 @@
using System.Diagnostics;
using System.Diagnostics.CodeAnalysis;
using System.Globalization;
using System.Runtime.InteropServices;

namespace System.Numerics
{
Expand Down Expand Up @@ -264,7 +263,7 @@ public BigInteger(ReadOnlySpan<byte> value, bool isUnsigned = false, bool isBigE
bool isNegative;
if (byteCount > 0)
{
byte mostSignificantByte = isBigEndian ? value[0] : value[^1];
byte mostSignificantByte = isBigEndian ? value[0] : value[byteCount - 1];
isNegative = (mostSignificantByte & 0x80) != 0 && !isUnsigned;

if (mostSignificantByte == 0)
Expand Down Expand Up @@ -640,12 +639,12 @@ public bool IsPowerOfTwo
AssertValid();

if (_bits == null)
return BitOperations.IsPow2(_sign);
return (_sign & (_sign - 1)) == 0 && _sign != 0;

if (_sign != 1)
return false;
int iu = _bits.Length - 1;
if (!BitOperations.IsPow2(_bits[iu]))
if ((_bits[iu] & (_bits[iu] - 1)) != 0)
return false;
while (--iu >= 0)
{
Expand Down Expand Up @@ -819,12 +818,12 @@ public static double Log(BigInteger value, double baseValue)
if (value._bits == null)
return Math.Log(value._sign, baseValue);

ulong h = value._bits[^1];
ulong m = value._bits.Length > 1 ? value._bits[^2] : 0;
ulong l = value._bits.Length > 2 ? value._bits[^3] : 0;
ulong h = value._bits[value._bits.Length - 1];
ulong m = value._bits.Length > 1 ? value._bits[value._bits.Length - 2] : 0;
ulong l = value._bits.Length > 2 ? value._bits[value._bits.Length - 3] : 0;

// Measure the exact bit count
int c = BitOperations.LeadingZeroCount((uint)h);
int c = NumericsHelpers.CbitHighZero((uint)h);
long b = (long)value._bits.Length * 32 - c;

// Extract most significant bits
Expand Down Expand Up @@ -990,17 +989,19 @@ public override int GetHashCode()

if (_bits == null)
return _sign;

HashCode hash = default;
hash.Add(_sign);
hash.AddBytes(MemoryMarshal.AsBytes(_bits.AsSpan()));
return hash.ToHashCode();
int hash = _sign;
for (int iv = _bits.Length; --iv >= 0;)
hash = NumericsHelpers.CombineHash(hash, unchecked((int)_bits[iv]));
return hash;
}

public override bool Equals([NotNullWhen(true)] object? obj)
{
AssertValid();
return obj is BigInteger other && Equals(other);

if (!(obj is BigInteger))
return false;
return Equals((BigInteger)obj);
}

public bool Equals(long other)
Expand Down Expand Up @@ -1123,9 +1124,9 @@ public int CompareTo(object? obj)
{
if (obj == null)
return 1;
if (obj is not BigInteger bigInt)
if (!(obj is BigInteger))
throw new ArgumentException(SR.Argument_MustBeBigInt, nameof(obj));
return CompareTo(bigInt);
return CompareTo((BigInteger)obj);
}

/// <summary>
Expand Down Expand Up @@ -1293,13 +1294,13 @@ private enum GetBytesMode { AllocateArray, Count, Span }
// because a bits array of all zeros would represent 0, and this case
// would be encoded as _bits = null and _sign = 0.
Debug.Assert(bits.Length > 0);
Debug.Assert(bits[^1] != 0);
Debug.Assert(bits[bits.Length - 1] != 0);
while (bits[nonZeroDwordIndex] == 0U)
{
nonZeroDwordIndex++;
}

highDword = ~bits[^1];
highDword = ~bits[bits.Length - 1];
if (bits.Length - 1 == nonZeroDwordIndex)
{
// This will not overflow because highDword is less than or equal to uint.MaxValue - 1.
Expand All @@ -1311,7 +1312,7 @@ private enum GetBytesMode { AllocateArray, Count, Span }
{
Debug.Assert(sign == 1);
highByte = 0x00;
highDword = bits[^1];
highDword = bits[bits.Length - 1];
}

byte msb;
Expand Down Expand Up @@ -1469,18 +1470,15 @@ private ReadOnlySpan<uint> ToUInt32Span(Span<uint> scratch)
}

// Find highest significant byte and ensure high bit is 0 if positive, 1 if negative
int msb = dwords.Length - 1;
while (msb > 0 && dwords[msb] == highDWord)
{
msb--;
}
int msb;
for (msb = dwords.Length - 1; msb > 0 && dwords[msb] == highDWord; msb--);
bool needExtraByte = (dwords[msb] & 0x80000000) != (highDWord & 0x80000000);

int length = msb + 1 + (needExtraByte ? 1 : 0);
bool copyDwordsToScratch = true;
if (length <= scratch.Length)
{
scratch = scratch[..length];
scratch = scratch.Slice(0, length);
copyDwordsToScratch = !dwordsIsScratch;
}
else
Expand All @@ -1490,7 +1488,7 @@ private ReadOnlySpan<uint> ToUInt32Span(Span<uint> scratch)

if (copyDwordsToScratch)
{
dwords[..(msb + 1)].CopyTo(scratch);
dwords.Slice(0, msb + 1).CopyTo(scratch);
}

if (needExtraByte)
Expand Down Expand Up @@ -1820,11 +1818,11 @@ public static explicit operator double(BigInteger value)
return double.NegativeInfinity;
}

ulong h = bits[^1];
ulong m = length > 1 ? bits[^2] : 0;
ulong l = length > 2 ? bits[^3] : 0;
ulong h = bits[length - 1];
ulong m = length > 1 ? bits[length - 2] : 0;
ulong l = length > 2 ? bits[length - 3] : 0;

int z = BitOperations.LeadingZeroCount((uint)h);
int z = NumericsHelpers.CbitHighZero((uint)h);

int exp = (length - 2) * 32 - z;
ulong man = (h << 32 + z) | (m << z) | (l >> 32 - z);
Expand Down Expand Up @@ -2418,7 +2416,7 @@ public long GetBitLength()
else
{
bitsArrayLength = bits.Length;
highValue = bits[^1];
highValue = bits[bitsArrayLength - 1];
}

long bitLength = bitsArrayLength * 32L - BitOperations.LeadingZeroCount(highValue);
Expand Down Expand Up @@ -2495,7 +2493,7 @@ private void AssertValid()
// Wasted space: _bits[0] could have been packed into _sign
Debug.Assert(_bits.Length > 1 || _bits[0] >= kuMaskHighBit);
// Wasted space: leading zeros could have been truncated
Debug.Assert(_bits[^1] != 0);
Debug.Assert(_bits[_bits.Length - 1] != 0);
}
else
{
Expand Down
36 changes: 35 additions & 1 deletion src/libraries/System.Runtime.Numerics/src/System/Numerics/BigIntegerCalculator.DivRem.cs
View file
Open in desktop
Original file line number Diff line number Diff line change
Expand Up @@ -173,7 +173,7 @@ private static unsafe void Divide(uint* left, int leftLength,
uint divLo = rightLength > 1 ? right[rightLength - 2] : 0;

// We measure the leading zeros of the divisor
int shift = BitOperations.LeadingZeroCount(divHi);
int shift = LeadingZeros(divHi);
int backShift = 32 - shift;

// And, we make sure the most significant bit is set
Expand Down Expand Up @@ -316,5 +316,39 @@ private static bool DivideGuessTooBig(ulong q, ulong valHi, uint valLo,

return false;
}

private static int LeadingZeros(uint value)
{
if (value == 0)
return 32;

int count = 0;
if ((value & 0xFFFF0000) == 0)
{
count += 16;
value = value << 16;
}
if ((value & 0xFF000000) == 0)
{
count += 8;
value = value << 8;
}
if ((value & 0xF0000000) == 0)
{
count += 4;
value = value << 4;
}
if ((value & 0xC0000000) == 0)
{
count += 2;
value = value << 2;
}
if ((value & 0x80000000) == 0)
{
count += 1;
}

return count;
}
}
}
2 changes: 1 addition & 1 deletion src/libraries/System.Runtime.Numerics/src/System/Numerics/BigIntegerCalculator.GcdInv.cs
View file
Open in desktop
Original file line number Diff line number Diff line change
Expand Up @@ -238,7 +238,7 @@ private static void ExtractDigits(ref BitsBuffer xBuffer,
}

// Use all the bits but one, see [hac] 14.58 (ii)
int z = BitOperations.LeadingZeroCount((uint)xh);
int z = LeadingZeros((uint)xh);

x = ((xh << 32 + z) | (xm << z) | (xl >> 32 - z)) >> 1;
y = ((yh << 32 + z) | (ym << z) | (yl >> 32 - z)) >> 1;
Expand Down
12 changes: 10 additions & 2 deletions src/libraries/System.Runtime.Numerics/src/System/Numerics/Complex.cs
View file
Open in desktop
Original file line number Diff line number Diff line change
Expand Up @@ -370,15 +370,23 @@ public static Complex Reciprocal(Complex value)

public override bool Equals([NotNullWhen(true)] object? obj)
{
return obj is Complex other && Equals(other);
if (!(obj is Complex)) return false;
return Equals((Complex)obj);
}

public bool Equals(Complex value)
{
return m_real.Equals(value.m_real) && m_imaginary.Equals(value.m_imaginary);
}

public override int GetHashCode() => HashCode.Combine(m_real, m_imaginary);
public override int GetHashCode()
{
int n1 = 99999997;
int realHash = m_real.GetHashCode() % n1;
int imaginaryHash = m_imaginary.GetHashCode();
int finalHash = realHash ^ imaginaryHash;
return finalHash;
}

public override string ToString() => $"({m_real}, {m_imaginary})";

Expand Down
Loading