Some important conditional fixes.

Author: Oren (electricessence)

IProcedureResult.cs

@@ -1,6 +1,10 @@
-namespace Open.Numeric
+using System.Diagnostics.CodeAnalysis;
+
+namespace Open.Numeric
 {
-	interface IProcedureResult<T>
+	// ReSharper disable once ArrangeTypeModifiers
+	[SuppressMessage("ReSharper", "UnusedMemberInSuper.Global")]
+	interface IProcedureResult<out T>
 	{
 		int Count { get; }
 		T Sum { get; }

Numeric.cs

@@ -44,7 +44,9 @@ public static double ToDouble(object value)
 			if (value == null)
 				return double.NaN;
 
-			return value is float ? ((float)value).ToDouble() : Convert.ToDouble(value);
+			return value is float f
+				? f.ToDouble()
+				: Convert.ToDouble(value);
 		}
 	}
 }

Precision.cs

@@ -66,7 +66,7 @@ public static int DecimalPlaces(this double source)
 			if (source.IsNaN())
 				return 0;
 
-			var valueString = source.ToString();
+			var valueString = source.ToString(CultureInfo.InvariantCulture); // To
 			var index = valueString.IndexOf('.');
 			return index == -1 ? 0 : valueString.Length - index - 1;
 		}
@@ -118,7 +118,8 @@ public static bool IsRelativeNearEqual(this double a, double b, uint minDecimalP
 		/// </summary>
 		public static bool IsPreciseEqual(this double a, double b, bool stringValidate = false)
 		{
-			return IsNearEqual(a, b, double.Epsilon) || (stringValidate && !double.IsNaN(a) && !double.IsNaN(b) && a.ToString() == b.ToString());
+			return IsNearEqual(a, b, double.Epsilon)
+				   || (stringValidate && !double.IsNaN(a) && !double.IsNaN(b) && a.ToString(CultureInfo.InvariantCulture) == b.ToString(CultureInfo.InvariantCulture));
 		}
 
 
@@ -127,7 +128,7 @@ public static bool IsPreciseEqual(this double a, double b, bool stringValidate =
 		/// </summary>
 		public static bool IsPreciseEqual(this float a, float b, bool stringValidate = false)
 		{
-			return IsNearEqual(a, b, float.Epsilon) || (stringValidate && !float.IsNaN(a) && !float.IsNaN(b) && a.ToString() == b.ToString());
+			return IsNearEqual(a, b, float.Epsilon) || (stringValidate && !float.IsNaN(a) && !float.IsNaN(b) && a.ToString(CultureInfo.InvariantCulture) == b.ToString(CultureInfo.InvariantCulture));
 		}
 
 		/// <summary>
@@ -151,20 +152,26 @@ public static bool IsPreciseEqual(this float? a, float? b, bool stringValidate =
 		/// <summary>
 		/// Shortcut for validating a if a potential floating pointvalue is close enough to another addValue using the given tolerance tolerance.
 		/// </summary>
-		public static bool IsNearEqual(this IComparable a, IComparable b, double tolerance)
+		public static bool IsNearEqual(this IComparable a, IComparable b, IComparable tolerance)
 		{
 			if (a == null)
 				throw new NullReferenceException();
 			if (b == null)
 				throw new ArgumentNullException(nameof(b));
 			Contract.EndContractBlock();
 
-			if (a is float)
-				return ((float)a).IsNearEqual((float)b, tolerance);
-			if (a is double)
-				return ((double)a).IsNearEqual((double)b, tolerance);
-			if (a is decimal)
-				return ((decimal)a).IsNearEqual((decimal)b, tolerance);
+			if (a.Equals(b))
+				return true;
+
+			switch (a)
+			{
+				case float f:
+					return IsNearEqual(f, (float)b, (float)tolerance);
+				case double d:
+					return IsNearEqual(d, (double)b, (double)tolerance);
+				case decimal @decimal:
+					return IsNearEqual(@decimal, (decimal)b, (decimal)tolerance);
+			}
 
 			throw new InvalidCastException();
 		}
@@ -199,21 +206,20 @@ public static double ToDouble(this float value)
 		/// </summary>
 		public static double ToDouble(this float? value)
 		{
-			return value.HasValue ? value.Value.ToDouble() : double.NaN;
+			return value?.ToDouble() ?? double.NaN;
 		}
 
 
 		/// <summary>
 		/// Accurate way to convert a possible float to double by rounding finite values to a decimal point tolerance level.
 		/// </summary>
-		/// <param name="tolerance"></param>	
 		public static double ToDouble(this float? value, int precision)
 		{
 			if (precision < 0 || precision > 15)
 				throw new ArgumentOutOfRangeException(nameof(precision), precision, "Must be bewteen 0 and 15.");
 			Contract.EndContractBlock();
 
-			return value.HasValue ? value.Value.ToDouble(precision) : double.NaN;
+			return value?.ToDouble(precision) ?? double.NaN;
 		}
 
 

ProcedureResult.cs

@@ -1,6 +1,7 @@
 
 using Open.Numeric.Precision;
 using System;
+using System.Globalization;
 
 namespace Open.Numeric
 {
@@ -26,7 +27,7 @@ public int CompareTo(ProcedureResult other)
 		{
 			var a = Average;
 			var b = other.Average;
-			if (a.IsNearEqual(b, 0.00000001) && a.ToString() == b.ToString()) return 0; // We hate precision issues. :(  1==1 dammit!
+			if (a.IsNearEqual(b, 0.00000001) && a.ToString(CultureInfo.InvariantCulture) == b.ToString(CultureInfo.InvariantCulture)) return 0; // We hate precision issues. :(  1==1 dammit!
 			if (a < b || double.IsNaN(a) && !double.IsNaN(b)) return -1;
 			if (a > b || !double.IsNaN(a) && double.IsNaN(b)) return +1;
 			if (Count < other.Count) return -1;

ProcedureResults.cs

@@ -18,7 +18,7 @@ public ProcedureResults(ReadOnlySpan<double> sum, int count)
 
 		static double[] SumValues(ReadOnlySpan<double> a, ReadOnlySpan<double> b)
 		{
-			if (a.Length != a.Length)
+			if (a.Length != b.Length)
 				throw new ArgumentException("Length mismatch.");
 
 			var len = a.Length;

Random.cs

@@ -5,21 +5,17 @@
 
 using System;
 using System.Collections.Generic;
+using System.Diagnostics.CodeAnalysis;
 using System.Linq;
 
 namespace Open.Numeric
 {
 	public static class RandomUtilities
 	{
 		static readonly Lazy<Random> R = new Lazy<Random>(() => new Random());
-		public static Random Random
-		{
-			get
-			{
-				return R.Value;
-			}
-		}
+		public static Random Random => R.Value;
 
+		[SuppressMessage("ReSharper", "PossibleNullReferenceException")]
 		public static bool TryRandomPluck<T>(this LinkedList<T> source, out T value)
 		{
 			if (source.Count == 0)

UEnumerable.cs

@@ -15,9 +15,7 @@ public static IEnumerable<ushort> Range(ushort start, ushort count)
 		}
 
 		public static IEnumerable<ushort> Range(ushort count)
-		{
-			return Range(0, count);
-		}
+			=> Range(0, count);
 
 
 		public static IEnumerable<uint> Range(uint start, uint count)
@@ -31,8 +29,6 @@ public static IEnumerable<uint> Range(uint start, uint count)
 		}
 
 		public static IEnumerable<uint> Range(uint count)
-		{
-			return Range(0, count);
-		}
+			=> Range(0, count);
 	}
 }