Merge pull request #13 from crookseta/2.x

Merge 2.0.0

Author: crookseta

README.md

@@ -1,6 +1,6 @@
-# MissingValues numeric library for .Net 7+
+# MissingValues numeric library for .Net 8+
 
-MissingValues is a C# numeric library for C# that introduces support for large integers and higher precision floating-point numbers. It supports .Net 7 Generic Math.
+MissingValues is a C# numeric library for C# that introduces support for large integers and higher precision floating-point numbers. It supports generic math.
 
 ## Features
 
@@ -29,49 +29,53 @@ Here is a chart comparing the existing binary integers to the MissingValues inte
 
 **Example Usage**
 
-	using MissingValues; // namespace
-	
-	// You can use the constructor:
-	Int256 num1 = new Int256(0x8000_0000_0000_0000, 0x0000_0000_0000_0000, 0x0000_0000_0000_0000, 0x0000_0000_0000_0001);
-	// You can use Parse():
-	Int256 num2 = Int256.Parse("10000000000000000000000000000000000000000000000000000000000000000000000000000");
-	// Or you can convert any other number type:
-	Int256 num3 = long.MaxValue;
+```csharp
+using MissingValues; // namespace
 
-	// sum = -57896044618658097711785492504343953926634992332820282019728792003956564819967 + 10000000000000000000000000000000000000000000000000000000000000000000000000000 + 9223372036854775807
-	Int256 sum = num1 + num2 + num3;
+// You can use the constructor:
+Int256 num1 = new Int256(0x8000_0000_0000_0000, 0x0000_0000_0000_0000, 0x0000_0000_0000_0000, 0x0000_0000_0000_0001);
+// You can use Parse():
+Int256 num2 = Int256.Parse("10000000000000000000000000000000000000000000000000000000000000000000000000000");
+// Or you can convert any other number type:
+Int256 num3 = long.MaxValue;
 
-	Console.WriteLine($"Sum: {sum}");
-	
-	// Prints: -47896044618658097711785492504343953926634992332820282019719568631919710044160
+// sum = -57896044618658097711785492504343953926634992332820282019728792003956564819967 + 10000000000000000000000000000000000000000000000000000000000000000000000000000 + 9223372036854775807
+Int256 sum = num1 + num2 + num3;
 
-### Quadruple-Precision Floating-Point Number
+Console.WriteLine($"Sum: {sum}");
 
-The library introduces the `Quad` struct, representing a quadruple-precision floating-point number. Quadruple-precision offers higher precision than standard `double` or `float` types, making it suitable for applications requiring extensive precision in numerical calculations.
+// Prints: -47896044618658097711785492504343953926634992332820282019719568631919710044160
+```
+### Quadruple-Precision and Octuple-Precision Floating-Point Number
 
-Here is a chart comparing the existing IEEE floating point numbers to `Quad`:
+The library introduces the `Quad` and `Octo` struct, representing a quadruple-precision floating-point and a octuple-precision floating-point number respectively. 
+Quadruple-precision offers higher precision than standard `double` or `float` types, making it suitable for applications requiring extensive precision in numerical calculations.
+
+Here is a chart comparing the existing IEEE floating point numbers to `Quad` and `Octo`:
 
 | Name   	| Size 		| Significand Digits 	| Decimal Digits 	| Max Exponent 	| Min Exponent 	| Max Value 	| Min Value  	|
 |--------	|--------	|--------------------	|----------------	|--------------	|--------------	|-----------	|------------	|
 | Half   	| 16 bits  	| 11                 	| 3.31           	| 15           	| -14          	| ~65504     	| ~-65500     	|
 | Single 	| 32 bits  	| 24                 	| 7.22           	| 127          	| -126         	| ~3.40e38   	| ~-3.40e38   	|
 | Double 	| 64 bits  	| 53                 	| 15.95          	| 1023         	| -1022        	| ~1.80e308  	| ~-1.79e308  	|
 | Quad   	| 128 bits 	| 113                	| 34.02          	| 16383        	| -16382       	| ~1.19e4932 	| ~-1.18e4932 	|
+| Octo   	| 256 bits 	| 237                	| 71.34          	| 262143        | −262142       | ~1.61e78913 	| ~-1.61e78913 	|
 
 **Example Usage**
+```csharp
+using MissingValues; // namespace
+
+// You can use the constructor:
+Quad num1 = new Quad(sign: false, exp: 0x4004, sig: new UInt128(0x0000_9400_0000_0000, 0x0000_0000_0000_0000));
+// You can use Parse():
+Quad num2 = Quad.Parse("2e24");
+// Or you can convert any other number type:
+Quad num3 = 12.25d;
+
+// sum = 50,5 + 2000000000000000000000000 + 12,25
+Quad sum = num1 + num2 + num3;
+
+Console.WriteLine($"Sum: {sum}");
 
-	using MissingValues; // namespace
-	
-	// You can use the constructor:
-	Quad num1 = new Quad(sign: false, exp: 0x4004, sig: new UInt128(0x0000_9400_0000_0000, 0x0000_0000_0000_0000));
-	// You can use Parse():
-	Quad num2 = Quad.Parse("2e24");
-	// Or you can convert any other number type:
-	Quad num3 = 12.25d;
-
-	// sum = 50,5 + 2000000000000000000000000 + 12,25
-	Quad sum = num1 + num2 + num3;
-
-	Console.WriteLine($"Sum: {sum}");
-	
-	// Prints 2000000000000000000000062,75
+// Prints 2000000000000000000000062,75
+```

changelog/2.x.x/2.0.md

@@ -0,0 +1,56 @@
+# MissingValues 2.X.X
+### Breaking changes
+- .Net 7 is no longer supported. MissingValues will now only support .Net 8 and up.
+- Library is no longer CLS compliant.
+- Numeric constants (`One`, `Zero`, `MaxValue`, etc.) are now readonly variables instead of properties.
+
+## 2.0.X Release Notes
+
+### More number formats support
+`MissingValues.UInt256`, `MissingValues.Int256`, `MissingValues.UInt512`, `MissingValues.Int512`, `MissingValues.Quad` and `MissingValues.Octo` 
+now support various numeric formats for their `ToString(string?, IFormatProvider?)` methods. the following formats are now supported:
+
+#### Currency format
+```csharp
+Int512.MaxValue.ToString("C", NumberFormatInfo.InvariantInfo);
+// Returns: ¤6,703,903,964,971,298,549,787,012,499,102,923,063,739,682,910,296,196,688,861,780,721,860,882,015,036,773,488,400,937,149,083,451,713,845,015,929,093,243,025,426,876,941,405,973,284,973,216,824,503,042,047.00
+```
+
+#### Scientific format
+```csharp
+Int512.MaxValue.ToString("E25", NumberFormatInfo.InvariantInfo);
+// Returns: 6.7039039649712985497870124991029230637396829102961966888617807218608820150367734884009371490834517138E+153
+```
+
+#### Fixed format
+```csharp
+Int512.MinValue.ToString("F", NumberFormatInfo.InvariantInfo);
+// Returns: -6703903964971298549787012499102923063739682910296196688861780721860882015036773488400937149083451713845015929093243025426876941405973284973216824503042048.00
+```
+
+#### Number format
+```csharp
+Int512.MinValue.ToString("N", NumberFormatInfo.InvariantInfo);
+// Returns: -6,703,903,964,971,298,549,787,012,499,102,923,063,739,682,910,296,196,688,861,780,721,860,882,015,036,773,488,400,937,149,083,451,713,845,015,929,093,243,025,426,876,941,405,973,284,973,216,824,503,042,048.00
+```
+
+### Octuple-precision floating-point
+Introducing `MissingValues.Octo` struct, representing a octuple-precision floating-point. Octuple-precision offers higher precision than even `MissingValues.Quad`.
+
+#### Construction
+Use the constructor the same way as `MissingValues.Quad`.
+```csharp
+// You can use the constructor:
+Octo num1 = new Octo(sign: false, exp: 0x40004, sig: new UInt256(0x0000_9400_0000_0000, 0x0000_0000_0000_0000, 0x0000_0000_0000_0000, 0x0000_0000_0000_0000));
+```
+
+#### Generic math support
+`MissingValues.Octo` supports .Net 7s generic math, implementing `System.Numerics.IBinaryFloatingPointIeee754<T>`.
+```csharp
+static void Add<T>(T x, T y) where T : IAdditionOperators<T, T, T>
+{
+	return x + y;
+}
+// You can use Octo:
+Octo z = Add(Octo.One, Octo.One);
+```

src/MissingValues.Benchmarks/BigIntegerBenchmarks.cs

@@ -0,0 +1,145 @@
+using BenchmarkDotNet.Attributes;
+using System.Numerics;
+
+namespace MissingValues.Benchmarks;
+
+[MinColumn, MaxColumn, MeanColumn, MedianColumn]
+[ShortRunJob]
+public class BigIntegerBenchmarks
+{
+	[ParamsSource(nameof(ValuesSource))]
+	public UInt128 Value { get; set; }
+	BigInteger b256, b512;
+	UInt256 u256;
+	UInt512 u512;
+
+	[GlobalSetup]
+	public void Setup()
+	{
+		u256 = (UInt256)(Int256.MaxValue / 2);
+		u512 = (UInt512)(Int512.MaxValue / 2);
+
+		Span<byte> bytes = stackalloc byte[UInt256.Size];
+		Int256.MaxValue.TryWriteLittleEndian(bytes);
+
+		b256 = new BigInteger(bytes, true);
+
+		bytes = stackalloc byte[UInt512.Size];
+		Int512.MaxValue.TryWriteLittleEndian(bytes);
+
+		b512 = new BigInteger(bytes, true);
+	}
+
+	[Benchmark]
+	public BigInteger Add_BigInteger256()
+	{
+		return b256 + Value;
+	}
+	[Benchmark]
+	public BigInteger Add_BigInteger512()
+	{
+		return b512 + Value;
+	}
+	[Benchmark]
+	public UInt256 Add_UInt256()
+	{
+		return u256 + Value;
+	}
+	[Benchmark]
+	public UInt512 Add_UInt512()
+	{
+		return u512 + Value;
+	}
+
+	[Benchmark]
+	public BigInteger Subtract_BigInteger256()
+	{
+		return b256 - Value;
+	}
+	[Benchmark]
+	public BigInteger Subtract_BigInteger512()
+	{
+		return b512 - Value;
+	}
+	[Benchmark]
+	public UInt256 Subtract_UInt256()
+	{
+		return u256 - Value;
+	}
+	[Benchmark]
+	public UInt512 Subtract_UInt512()
+	{
+		return u512 - Value;
+	}
+
+	[Benchmark]
+	public BigInteger Multiply_BigInteger256()
+	{
+		return b256 * Value;
+	}
+	[Benchmark]
+	public BigInteger Multiply_BigInteger512()
+	{
+		return b512 * Value;
+	}
+	[Benchmark]
+	public UInt256 Multiply_UInt256()
+	{
+		return u256 * Value;
+	}
+	[Benchmark]
+	public UInt512 Multiply_UInt512()
+	{
+		return u512 * Value;
+	}
+
+	[Benchmark]
+	public BigInteger Divide_BigInteger256()
+	{
+		return b256 / Value;
+	}
+	[Benchmark]
+	public BigInteger Divide_BigInteger512()
+	{
+		return b512 / Value;
+	}
+	[Benchmark]
+	public UInt256 Divide_UInt256()
+	{
+		return u256 / Value;
+	}
+	[Benchmark]
+	public UInt512 Divide_UInt512()
+	{
+		return u512 / Value;
+	}
+
+	[Benchmark]
+	public BigInteger Remainder_BigInteger256()
+	{
+		return b256 % Value;
+	}
+	[Benchmark]
+	public BigInteger Remainder_BigInteger512()
+	{
+		return b512 % Value;
+	}
+	[Benchmark]
+	public UInt256 Remainder_UInt256()
+	{
+		return u256 % Value;
+	}
+	[Benchmark]
+	public UInt512 Remainder_UInt512()
+	{
+		return u512 % Value;
+	}
+
+	public IEnumerable<UInt128> ValuesSource()
+	{
+		yield return UInt128.Parse("1");
+		yield return UInt128.Parse("2");
+		yield return UInt128.Parse("10000000000000000000");
+		yield return UInt128.Parse("100000000000000000000000000000000000000");
+	}
+}

src/MissingValues.Benchmarks/GenericIntegerBenchmarks.cs

@@ -0,0 +1,99 @@
+using BenchmarkDotNet.Attributes;
+using MissingValues.Internals;
+using System;
+using System.Collections.Generic;
+using System.Globalization;
+using System.Linq;
+using System.Numerics;
+using System.Runtime.CompilerServices;
+using System.Text;
+using System.Threading.Tasks;
+
+namespace MissingValues.Benchmarks
+{
+	[MinColumn, MaxColumn, MeanColumn, MedianColumn]
+	[GenericTypeArguments(typeof(int))]
+	[GenericTypeArguments(typeof(long))]
+	[GenericTypeArguments(typeof(Int128))]
+	[GenericTypeArguments(typeof(Int256))]
+	[GenericTypeArguments(typeof(Int512))]
+	public class GenericIntegerBenchmarks<T>
+		where T : INumber<T>
+	{
+		[Params(100, 10_000, 250_000, 750_000)]
+		public int Length;
+
+		private T[] _v1, _v2;
+		private T[] _destination;
+		private string[] _toString;
+
+		[GlobalSetup]
+		public void Setup()
+		{
+			_v1 = new T[Length];
+			_v2 = new T[Length];
+
+			Span<byte> bytes = stackalloc byte[Unsafe.SizeOf<T>()];
+
+			for (int i = 0; i < Length; i++)
+			{
+				Random.Shared.NextBytes(bytes);
+				_v1[i] = Unsafe.ReadUnaligned<T>(ref bytes[0]);
+			}
+			Random.Shared.GetItems(_v1, _v2.AsSpan());
+
+			_destination = new T[Length];
+			_toString = new string[Length];
+		}
+
+		[Benchmark]
+		public T[] Add_Integer()
+		{
+			for (int i = 0; i < Length; i++)
+			{
+				_destination[i] = _v1[i] + _v2[i];
+			}
+			return _destination;
+		}
+
+		[Benchmark]
+		public T[] Subtract_Integer()
+		{
+			for (int i = 0; i < Length; i++)
+			{
+				_destination[i] = _v1[i] - _v2[i];
+			}
+			return _destination;
+		}
+
+		[Benchmark]
+		public T[] Multiply_Integer()
+		{
+			for (int i = 0; i < Length; i++)
+			{
+				_destination[i] = _v1[i] * _v2[i];
+			}
+			return _destination;
+		}
+
+		[Benchmark]
+		public T[] Divide_Integer()
+		{
+			for (int i = 0; i < Length; i++)
+			{
+				_destination[i] = _v1[i] / _v2[i];
+			}
+			return _destination;
+		}
+
+		[Benchmark]
+		public string[] ToString_Integer()
+		{
+			for (int i = 0; i < Length; i++)
+			{
+				_toString[i] = _v1[i].ToString()!;
+			}
+			return _toString;
+		}
+	}
+}