Generic Type Constraint to accept only Numbers?

Question

Possible Duplicates:
C# generic constraint for only integers
Generics - where T is a number?

In c#:

Imagine a case that we have a functionality over a generic type in which conceptually our generic type is limited only to numbers.

By saying "number" we aim to be able to use multiply, plus, minus, etc. operators on variables of type T.

Unfortunately something like this is not accepted in c#:

public class Image<T> where T : number

Note that performance is also important so we don't want to go for redefining a struct for numeric types and using them.

What do you think is the best way to do this? Or is there any design patter that allows us to have "high performance" arithmetic functions over variables of a generic type?

It does not exist. One of the biggest flaws of .net IMO. You can use `MiscUtil`'s operator class, but it's rather slow. Some C# numerics projects use a code generator to create versions of their code for the common number types. [[Jeff Avatar Image]] — CodesInChaos, Jul 06 '11 at 13:33

score 1 · Answer 1 · answered Jul 06 '11 at 13:23

1

Unfortunately there is no such constraint. The closest thing exist is struct constraint

Also you can google math libraries for .net which expose there own types which have one baseclass which makes it possible to use it as a constrain you want.

answered Jul 06 '11 at 13:23

vittore

17,449
6
44
82

dtb · Accepted Answer · 2011-07-06T13:47:34.800

At the great cost of losing readability, you can rewrite all methods from

int Factorial(int x)
{
    if (x == 0) return 1;
    return x * Factorial(x - 1);
}

to

T Factorial<T>(IReal<T> t, T x)
{
    if (t.Equals(x, t.FromInteger(0))) return t.FromInteger(1);
    return t.Multiply(x, Factorial<T>(t, t.Subtract(x, t.FromInteger(1))));
}

using

interface IEq<T>
{
    bool Equals(T a, T b);
}

interface IOrd<T> : IEq<T>
{
    int Compare(T a, T b);
}

interface IShow<T>
{
    string Show(T a);
}

interface INum<T> : IEq<T>, IShow<T>
{
    T Add(T a, T b);
    T Subtract(T a, T b);
    T Multiply(T a, T b);

    T Negate(T a);

    T Abs(T a);
    T Signum(T a);

    T FromInteger(int x);
}

interface IReal<T> : INum<T>, IOrd<T>
{
}

with implementations for any number type.

It's not only readability you use, it's also performance you lose. — CodesInChaos, Jul 06 '11 at 13:39

Generic Type Constraint to accept only Numbers?

2 Answers2