In .NET 6 we previewed a feature known as Generic Math. Since then, we have made continuous improvements to the implementation and responded to various feedback from the community in order to ensure that relevant scenarios are possible and the necessary APIs are available.<\/p>\n
If you missed out on the original blog post<\/a>, Generic Math combines the power of generics and a new feature known as Much like generics, this feature will see the most benefits by API authors where they can simplify the amount of code required they need to maintain. The .NET Libraries did just this<\/a> to simplify the Lets take a look at an example piece of code that computes a standard deviation. For those unfamiliar, this is a math function used in statistics that builds on two simpler methods: The first method we’ll look at is The next method is These methods can then be used with any type that implements the required interfaces and in .NET 7 preview 5 we have 20 types that implement these interfaces out of the box. The following table gives a brief description of those types, the corresponding language keyword for C# and F# when that exists, and the primary generic math interfaces they implement. More details on these interfaces and why they exist are provided later on in the Available APIs<\/a> section.<\/p>\nstatic virtuals in interfaces<\/code> to allow .NET developers to take advantage of static APIs, including operators, from generic code. This means that you get all the power of generics, but now with the ability to constrain the input to number like types, so you no longer need to write or maintain many near identical implementations just to support multiple types. It also means that you get access to all your favorite operators and can use them from generic contexts. That is, you can now have static T Add<T>(T left, T right) where T : INumber<T> => left + right;<\/code> where-as previously it would have been impossible to define.<\/p>\nEnumerable.Min<\/code> and Enumerable.Max<\/code> APIs exposed as part of LINQ. Other developers will benefit indirectly as the APIs they consume may start supporting more types without the requirement for each and every numeric type to get explicit support. Once an API supports INumber<T><\/code> then it should work with any type that implements the required interface. All devs will likewise benefit from having a more consistent API surface and having more functionality available by default. For example, all types that implement IBinaryInteger<T><\/code> will support operations like +<\/code> (Addition), -<\/code> (Subtraction), <<<\/code> (Left Shift), and LeadingZeroCount<\/code>.<\/p>\nGeneric Math<\/h2>\n
Sum<\/code> and Average<\/code>. It is basically used to determine how spread apart a set of values are.<\/p>\nSum<\/code>, which just adds a set of values together. The method takes in an IEnumerable<T><\/code> where T<\/code> must be a type that implements the INumber<T><\/code> interface. It returns a TResult<\/code> with a similar constraint (it must be a type that implements INumber<TResult><\/code>). Because two generic parameters are here, it is allowed to return a different type than it takes as an input. This means, for example, you can do Sum<int, long><\/code> which would allow summing the values of an int[]<\/code> and returning a 64-bit result to help avoid overflow. TResult.Zero<\/code> efficiently gives the value of 0<\/code> as a TResult<\/code> and TResult.CreateChecked<\/code> converts value<\/code> from a T<\/code> into a TResult<\/code> throwing an OverflowException<\/code> if it is too large or too small to fit in the destination format. This means, for example, that Sum<int, byte><\/code> would throw if one of the input values was negative or greater than 255<\/code>.<\/p>\npublic static TResult Sum<T, TResult>(IEnumerable<T> values)\r\n where T : INumber<T>\r\n where TResult : INumber<TResult>\r\n{\r\n TResult result = TResult.Zero;\r\n\r\n foreach (var value in values)\r\n {\r\n result += TResult.CreateChecked(value);\r\n }\r\n\r\n return result;\r\n}<\/code><\/pre>\nAverage<\/code>, which just adds a set of values together (calls Sum<\/code>) and then divides that by the number of values. It doesn’t introduce any additional concepts beyond what were used in Sum<\/code>. It does show use of the division operator.<\/p>\npublic static TResult Average<T, TResult>(IEnumerable<T> values)\r\n where T : INumber<T>\r\n where TResult : INumber<TResult>\r\n{\r\n TResult sum = Sum<T, TResult>(values);\r\n return TResult.CreateChecked(sum) \/ TResult.CreateChecked(values.Count());\r\n}<\/code><\/pre>\nStandardDeviation<\/code> is the last method, as indicated above it basically determines how far apart a set of values are. For example, { 0, 50, 100 }<\/code> has a high deviation of 49.501<\/code>; { 0, 5, 10 }<\/code> on the other hand has a much lower deviation of just 4.5092<\/code>. This method introduces a different constraint of IFloatingPointIeee754<\/code> which indicates the return type must be an IEEE 754<\/code> floating-point type such as double<\/code> (System.Double<\/code>) or float<\/code> (System.Single<\/code>). It introduces a new API CreateSaturating<\/code> which explicitly saturates, or clamps, the value on overflow. That is, for byte.CreateSaturating<int>(value)<\/code> it would convert -1<\/code> to 0<\/code> because -1<\/code> is less than the minimum value of 0<\/code>. It would likewise convert 256<\/code> to 255<\/code> because 256<\/code> is greater than the maximum value of 255<\/code>. Saturation is the default behavior for IEEE 754<\/code> floating-point types as they can represent positive and negative infinity as their respective minimum and maximum values. The only other new API is Sqrt<\/code> which behaves just like Math.Sqrt<\/code> or MathF.Sqrt<\/code> and calculates the square root<\/code> of the floating-point value.<\/p>\npublic static TResult StandardDeviation<T, TResult>(IEnumerable<T> values)\r\n where T : INumber<T>\r\n where TResult : IFloatingPointIeee754<TResult>\r\n{\r\n TResult standardDeviation = TResult.Zero;\r\n\r\n if (values.Any())\r\n {\r\n TResult average = Average<T, TResult>(values);\r\n TResult sum = Sum<TResult, TResult>(values.Select((value) => {\r\n var deviation = TResult.CreateSaturating(value) - average;\r\n return deviation * deviation;\r\n }));\r\n standardDeviation = TResult.Sqrt(sum \/ TResult.CreateSaturating(values.Count() - 1));\r\n }\r\n\r\n return standardDeviation;\r\n}<\/code><\/pre>\n