it-swarm-es.tech

Crear una biblioteca matemática usando genéricos en C #

¿Existe alguna forma viable de utilizar genéricos para crear una biblioteca matemática que no dependa del tipo base elegido para almacenar datos?

En otras palabras, supongamos que quiero escribir una clase de fracción. La fracción se puede representar por dos ints o dos dobles o todo eso. Lo importante es que las cuatro operaciones aritméticas básicas estén bien definidas. Entonces, me gustaría poder escribir Fraction<int> frac = new Fraction<int>(1,2) y/o Fraction<double> frac = new Fraction<double>(0.1, 1.0).

Desafortunadamente, no existe una interfaz que represente las cuatro operaciones básicas (+, -, *, /). ¿Alguien ha encontrado una forma viable y viable de implementar esto?

28
Sklivvz

Aquí hay una forma de abstraer a los operadores que es relativamente sencilla.

    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 no implementa un tipo que usa, obtendrá una falla en tiempo de ejecución en lugar de en tiempo de compilación (eso es malo). La definición de MathProvider<T> las implementaciones siempre serán las mismas (también malas). Sugeriría que simplemente evite hacer esto en C # y use F # o algún otro lenguaje que se adapte mejor a este nivel de abstracción.

Editar: Definiciones fijas de sumar y restar para Fraction<T>. Otra cosa interesante y sencilla de hacer es implementar un MathProvider que opere en un árbol de sintaxis abstracto. Esta idea apunta inmediatamente a hacer cosas como la diferenciación automática: http://conal.net/papers/beautiful-differentiation/

29
fryguybob

Creo que esto responde a tu pregunta:

http://www.codeproject.com/KB/cs/genericnumerics.aspx

6
Peter

Aquí hay un problema sutil que viene con los tipos genéricos. Suponga que un algoritmo implica división, digamos eliminación gaussiana para resolver un sistema de ecuaciones. Si ingresa números enteros, obtendrá una respuesta incorrecta porque realizará la división integer. Pero si pasa argumentos dobles que tienen valores enteros, obtendrá la respuesta correcta.

Lo mismo ocurre con las raíces cuadradas, como en la factorización de Cholesky. Factorizar una matriz entera saldrá mal, mientras que factorizar una matriz de dobles que tiene valores enteros estará bien.

3
John D. Cook

Primero, su clase debe limitar el parámetro genérico a primitivas (Fracción de clase pública donde T: struct, new ()).

En segundo lugar, probablemente necesitará crear sobrecargas de conversión implícitas para poder manejar la conversión de un tipo a otro sin que el compilador llore.

En tercer lugar, también puede sobrecargar los cuatro operadores básicos para que la interfaz sea más flexible al combinar fracciones de diferentes tipos.

Por último, debe considerar cómo está manejando los desbordamientos y subdesbordamientos aritméticos. Una buena biblioteca será extremadamente explícita en cómo maneja los desbordamientos; de lo contrario, no puede confiar en el resultado de operaciones de diferentes tipos de fracciones.

2
Will