La création d'une bibliothèque de Mathématiques à l'aide de médicaments Génériques en C#

Ici est un moyen d'abstraire les opérateurs, ce qui est relativement indolore.

    abstract class MathProvider<T>
{
public abstract T Divide(T a, T b);
public abstract T Multiply(T a, T b);
public abstract T Add(T a, T b);
public abstract T Negate(T a);
public virtual T Subtract(T a, T b)
{
return Add(a, Negate(b));
}
}
class DoubleMathProvider : MathProvider<double>
{
public override double Divide(double a, double b)
{
return a / b;
}
public override double Multiply(double a, double b)
{
return a * b;
}
public override double Add(double a, double b)
{
return a + b;
}
public override double Negate(double a)
{
return -a;
}
}
class IntMathProvider : MathProvider<int>
{
public override int Divide(int a, int b)
{
return a / b;
}
public override int Multiply(int a, int b)
{
return a * b;
}
public override int Add(int a, int b)
{
return a + b;
}
public override int Negate(int a)
{
return -a;
}
}
class Fraction<T>
{
static MathProvider<T> _math;
//Notice this is a type constructor.  It gets run the first time a
//variable of a specific type is declared for use.
//Having _math static reduces overhead.
static Fraction()
{
//This part of the code might be cleaner by once
//using reflection and finding all the implementors of
//MathProvider and assigning the instance by the one that
//matches T.
if (typeof(T) == typeof(double))
_math = new DoubleMathProvider() as MathProvider<T>;
else if (typeof(T) == typeof(int))
_math = new IntMathProvider() as MathProvider<T>;
//... assign other options here.
if (_math == null)
throw new InvalidOperationException(
"Type " + typeof(T).ToString() + " is not supported by Fraction.");
}
//Immutable impementations are better.
public T Numerator { get; private set; }
public T Denominator { get; private set; }
public Fraction(T numerator, T denominator)
{
//We would want this to be reduced to simpilest terms.
//For that we would need GCD, abs, and remainder operations
//defined for each math provider.
Numerator = numerator;
Denominator = denominator;
}
public static Fraction<T> operator +(Fraction<T> a, Fraction<T> b)
{
return new Fraction<T>(
_math.Add(
_math.Multiply(a.Numerator, b.Denominator),
_math.Multiply(b.Numerator, a.Denominator)),
_math.Multiply(a.Denominator, b.Denominator));
}
public static Fraction<T> operator -(Fraction<T> a, Fraction<T> b)
{
return new Fraction<T>(
_math.Subtract(
_math.Multiply(a.Numerator, b.Denominator),
_math.Multiply(b.Numerator, a.Denominator)),
_math.Multiply(a.Denominator, b.Denominator));
}
public static Fraction<T> operator /(Fraction<T> a, Fraction<T> b)
{
return new Fraction<T>(
_math.Multiply(a.Numerator, b.Denominator),
_math.Multiply(a.Denominator, b.Numerator));
}
//... other operators would follow.
}

Si vous ne parvenez pas à mettre en œuvre un type que vous utilisez, vous obtiendrez un échec à l'exécution au lieu de au moment de la compilation (c'est mauvais). La définition de la MathProvider<T> implémentations est toujours le même (mauvais). Je suggère que vous venez d'éviter de le faire en C# et F# ou une autre langue mieux adaptés à ce niveau d'abstraction.

Edit: Fixe les définitions d'ajouter et de soustraire pour Fraction<T>.
Une autre intéressante et simple chose à faire est de mettre en œuvre un MathProvider qui fonctionne sur un arbre de syntaxe abstraite. Cette idée immédiatement des points pour faire des choses comme la différentiation automatique: http://conal.net/papers/beautiful-differentiation/

Voici un problème subtil qui vient avec des types génériques. Supposons qu'un algorithme implique la division, dire l'élimination de Gauss pour résoudre un système d'équations. Si vous passez dans les entiers, vous obtiendrez une réponse erronée parce que vous devrez mener à bien entier division. Mais si vous passez dans le double arguments qui se produisent ont une valeur entière, vous aurez le droit de réponse.

La même chose se produit avec des racines carrées, comme dans la factorisation de Cholesky. La factorisation d'un entier de la matrice va aller mal, alors que la factorisation d'une matrice de doubles qui ont une valeur entière sera fine.