That-One-Nerd/Nerd_STF
1
0
Fork 0
Code Issues 63 Pull Requests Actions Packages Projects Releases 19 Wiki Activity

Releasing Nerd_STF version 2.4.0. #88

Merged
That-One-Nerd merged 16 commits from canary into main 2023-07-10 00:25:18 -04:00
Conversation 0 Commits 16 Files Changed 59 +112 -3
1 changed files with 112 additions and 3 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files
Showing only changes of commit af4ed70add - Show all commits

115
Nerd_STF/Mathematics/BigInteger.cs
View File

@ -2,9 +2,15 @@
namespace Nerd_STF.Mathematics;
public readonly struct BigInteger/* : IAbsolute<BigInteger>, IAverage<BigInteger>, IClamp<BigInteger>, IDivide<BigInteger>,
ILerp<BigInteger, float>, IMathOperators<BigInteger>, IMax<BigInteger>, IMedian<BigInteger>, IMin<BigInteger>,
IPresets1d<BigInteger>, IProduct<BigInteger>, ISubtract<BigInteger>, ISum<BigInteger>*/
public readonly struct BigInteger/* : IAbsolute<BigInteger>, IAverage<BigInteger>, IClamp<BigInteger>,
IComparable<BigInteger>, IComparable<byte>, IComparable<sbyte>, IComparable<short>, IComparable<ushort>,
IComparable<int>, IComparable<uint>, IComparable<long>, IComparable<ulong>, IComparable<Half>,
IComparable<float>, IComparable<double>, IComparable<decimal>, IDivide<BigInteger>, IEquatable<BigInteger>,
IEquatable<byte>, IEquatable<sbyte>, IEquatable<short>, IEquatable<ushort>, IEquatable<int>, IEquatable<uint>,
IEquatable<long>, IEquatable<ulong>, IEquatable<Half>, IEquatable<float>, IEquatable<double>,
IEquatable<decimal>, ILerp<BigInteger, float>, IMathOperators<BigInteger>, IMax<BigInteger>,
IMedian<BigInteger>, IMin<BigInteger>, IPresets1d<BigInteger>, IProduct<BigInteger>, ISubtract<BigInteger>,
ISum<BigInteger>*/
{
public static BigInteger One => new(false, new byte[] { 1 });
public static BigInteger Zero => new(false, Array.Empty<byte>());
@ -91,10 +97,113 @@ public readonly struct BigInteger/* : IAbsolute<BigInteger>, IAverage<BigInteger
}
public ulong ToUInt64() => (ulong)ToInt64();
public int CompareTo(byte other) => CompareTo((BigInteger)other);
public int CompareTo(sbyte other) => CompareTo((BigInteger)other);
public int CompareTo(ushort other) => CompareTo((BigInteger)other);
public int CompareTo(short other) => CompareTo((BigInteger)other);
public int CompareTo(uint other) => CompareTo((BigInteger)other);
public int CompareTo(int other) => CompareTo((BigInteger)other);
public int CompareTo(ulong other) => CompareTo((BigInteger)other);
public int CompareTo(long other) => CompareTo((BigInteger)other);
public int CompareTo(Half other) => CompareTo((BigInteger)other);
public int CompareTo(float other) => CompareTo((BigInteger)other);
public int CompareTo(double other) => CompareTo((BigInteger)other);
public int CompareTo(decimal other) => CompareTo((BigInteger)other);
public int CompareTo(BigInteger other)
{
int compare = p_sign.CompareTo(other.p_sign);
if (compare != 0) return compare;
compare = p_data.Length.CompareTo(other.p_data);
if (compare != 0) return compare;
for (int i = p_data.Length - 1; i >= 0; i--)
{
compare = p_data[i].CompareTo(other.p_data[i]);
if (compare != 0) return compare;
}
return 0;
}
public override bool Equals([NotNullWhen(true)] object? obj)
{
if (obj is null) return false;
else if (obj is BigInteger val) return Equals(val);
else if (obj is byte valUInt8) return Equals(valUInt8);
else if (obj is sbyte valInt8) return Equals(valInt8);
else if (obj is ushort valUInt16) return Equals(valUInt16);
else if (obj is short valInt16) return Equals(valInt16);
else if (obj is uint valUInt32) return Equals(valUInt32);
else if (obj is int valInt32) return Equals(valInt32);
else if (obj is ulong valUInt64) return Equals(valUInt64);
else if (obj is long valInt64) return Equals(valInt64);
else if (obj is Half valHalf) return Equals(valHalf);
else if (obj is float valSingle) return Equals(valSingle);
else if (obj is double valDouble) return Equals(valDouble);
else if (obj is decimal valDecimal) return Equals(valDecimal);
return base.Equals(obj);
}
public bool Equals(byte other) => Equals((BigInteger)other);
public bool Equals(sbyte other) => Equals((BigInteger)other);
public bool Equals(ushort other) => Equals((BigInteger)other);
public bool Equals(short other) => Equals((BigInteger)other);
public bool Equals(uint other) => Equals((BigInteger)other);
public bool Equals(int other) => Equals((BigInteger)other);
public bool Equals(ulong other) => Equals((BigInteger)other);
public bool Equals(long other) => Equals((BigInteger)other);
public bool Equals(Half other) => Equals((BigInteger)other);
public bool Equals(float other) => Equals((BigInteger)other);
public bool Equals(double other) => Equals((BigInteger)other);
public bool Equals(decimal other) => Equals((BigInteger)other);
public bool Equals(BigInteger other) => p_sign == other.p_sign;
public override int GetHashCode() => base.GetHashCode();
public override string ToString()
{
return ToInt64().ToString(); // This isn't good because it doesn't work for numbers larger than 2^63
}
private byte[] GetDataOfSize(int bytes)
{
byte[] data = new byte[bytes];
Array.Copy(p_data, data, Mathf.Min(p_data.Length, bytes));
return data;
}
private byte[] TrimmedData()
{
int start = 0;
while (start < p_data.Length && p_data[start] == 0) start++;
return p_data.Skip(start).ToArray();
}
public static bool operator ==(BigInteger a, BigInteger b) => a.Equals(b);
public static bool operator !=(BigInteger a, BigInteger b) => !a.Equals(b);
public static bool operator >(BigInteger a, BigInteger b) => a.CompareTo(b) > 0;
public static bool operator <(BigInteger a, BigInteger b) => a.CompareTo(b) < 0;
public static bool operator >=(BigInteger a, BigInteger b) => a == b || a > b;
public static bool operator <=(BigInteger a, BigInteger b) => a == b || a < b;
public static implicit operator BigInteger(byte val) => new(val);
public static implicit operator BigInteger(sbyte val) => new(val);
public static implicit operator BigInteger(ushort val) => new(val);
public static implicit operator BigInteger(short val) => new(val);
public static implicit operator BigInteger(uint val) => new(val);
public static implicit operator BigInteger(int val) => new(val);
public static implicit operator BigInteger(ulong val) => new(val);
public static implicit operator BigInteger(long val) => new(val);
public static explicit operator BigInteger(Half val) => new((int)val);
public static explicit operator BigInteger(float val) => new((int)val);
public static explicit operator BigInteger(double val) => new((long)val);
public static explicit operator BigInteger(decimal val) => new((long)val);
public static explicit operator byte(BigInteger val) => val.ToUInt8();
public static explicit operator sbyte(BigInteger val) => val.ToInt8();
public static explicit operator ushort(BigInteger val) => val.ToUInt16();
public static explicit operator short(BigInteger val) => val.ToInt16();
public static explicit operator uint(BigInteger val) => val.ToUInt32();
public static explicit operator int(BigInteger val) => val.ToInt32();
public static explicit operator ulong(BigInteger val) => val.ToUInt64();
public static explicit operator long(BigInteger val) => val.ToInt64();
public static explicit operator Half(BigInteger val) => (Half)val.ToInt32();
public static explicit operator float(BigInteger val) => val.ToInt32();
public static explicit operator double(BigInteger val) => val.ToInt64();
public static explicit operator decimal(BigInteger val) => val.ToInt64();
}