How to Implement Generic Method to do Math calculations on different value types

Question

I have a method that accepts an IEnumerable-decimals and performance various math functions. I want to use the same method on an IEnumerable-int-. How do I implement this? For example to find a simple sum?

void Calculate<T>(IEnumerable <T> ListOFNumbers)
{
   int count= ListofNumbers.Count();
   ?sum=?;
}

Answer 1

You can use the IEnumerable.Sum function

Answer 2

This is purely looking and jumping around in reflector.

{
   IQueryable qt = ListofNumbers.AsQueryable();
   Console.WriteLine(qt.Sum());
}

Answer 3

You can use the built-in LINQ Aggregate(...) method to do this and many other more complicated calculations i.e.

int[] n = new int[] { 1, 2, 3, 4, 4, 5, 5, 6 };
int sum = n.Aggregate((x, y) => x + y);

as the lamdba is executed, once for each element in the enumeration the values of x,y are

0,1
1,2
3,3
6,4,
10,4,
14,5,
19,5
24,6

respectively and the final result is 30

With this you can use any aggregating function you want:

For example:

int[] n = new int[] { 1, 2, 3, 4, 4, 5, 5, 6 };
int count = n.Aggregate((x, y) => x + 1);

To simplify this there are built-in functions for common aggregates like Count and Max. Hope this helps

Alex

Answer 4

This is all freely available in MiscUtil. The Operator class provides access to generic arithmetic; and there are generic implementations (as extension methods) of Sum, Average, etc - and works with any type with suitable operators in addition to the primitives. So for example, you could use Sum with of Complex<T>, etc.

Note that it currently uses .NET 3.5; I did have a 2.0 version somewhere, but it isn't as tested....

A simplified example of sum is shown in the usage document:

public static T Sum<T>(this IEnumerable<T> source)
{
    T sum = Operator<T>.Zero;
    foreach (T value in source)
    {
        if (value != null)
        {
            sum = Operator.Add(sum, value);
        }
    }
    return sum;
}

Although IIRC the actual implementation has a bit more...

As an aside, note that dynamic (in .NET 4.0 / C# 4.0) supposedly supports operators, but we'll have to wait for the beta to see what it does. From my previous looks at dynamic in the CTP, I expect it to be a bit slower than the MiscUtil code, but we shall see.