c# - libreria - funciones matematicas en programacion

Diferenciación de funciones matemáticas con C#?

Question

Veo que puedo declarar una función con (decir)

public double Function(double parameter)

pero ¿y si quiero tomar la derivada de esa función?

Answer 1

¿Estás pensando en Lambda Expressions?

Básicamente puedes pasar una función a una función.

Así que piense en Sort en un objeto. Dependiendo de la naturaleza del objeto, ayudaría a determinar cómo se ordenan los objetos.

Pero aún puede crear una función de clasificación genérica y luego pasar cómo comparar objetos.

Answer 2

Si ha escrito la función, ya ha sido derivada.

Y dado que es una función int, asumiré que no se refiere a la definición de cálculo de "derivar".

Answer 3

Si estás pensando en la manipulación simbólica de fórmulas, entonces es mejor que hagas tus derivaciones en idiomas como Maple o Mathematica. Están diseñados para computación simbólica.

EDITAR: Si Maple y Mathematica son demasiado caros para ti, entonces hay otras opciones. Wikipedia tiene una lista bastante completa de paquetes de álgebra informática. http://en.wikipedia.org/wiki/Comparison_of_computer_algebra_systems

Answer 4

No puede calcular la derivada exacta de una función usando un programa de computadora (a menos que esté haciendo matemática simbólica ... pero ese es otro tema mucho más complicado).

Hay varios enfoques para calcular una derivada numérica de una función. El más simple es el método centrado de tres puntos:

• Toma un pequeño número h
• Evaluar [f(x+h) - f(xh)] / 2h
• Voilà, una aproximación de f ''(x), con solo dos evaluaciones de funciones

Otro enfoque es el método centrado de cinco puntos:

• Toma un pequeño número h
• Evaluar [f(x-2h) - 8f(xh) + 8f(x+h) - f(x+2h)] / 12h
• Voilà, una mejor aproximación de f ''(x), pero requiere más evaluaciones de funciones

Otro tema es cómo implementar esto usando C #. En primer lugar, necesita un delegado que represente una función que asigne un subconjunto de los números reales a otro subconjunto de los números reales:

delegate double RealFunction(double arg);

Entonces, necesitas una ruta que evalúe la derivada:

public double h = 10e-6; // I''m not sure if this is valid C#, I''m used to C++

static double Derivative(RealFunction f, double arg)
{
    double h2 = h*2;
    return (f(x-h2) - 8*f(x-h) + 8*f(x+h) - f(x+h2)) / (h2*6);
}

Si desea una implementación orientada a objetos, debe crear las siguientes clases:

interface IFunction
{
    // Since operator () can''t be overloaded, we''ll use this trick.
    double this[double arg] { get; }
}

class Function : IFunction
{
    RealFunction func;

    public Function(RealFunction func)
    { this.func = func; }

    public double this[double arg]
    { get { return func(arg); } }
}

class Derivative : IFunction
{
    IFunction func;
    public static double h = 10e-6;

    public Derivative(IFunction func)
    { this.func = func; }

    public double this[double arg]
    {
        get
        {
            double h2 = h*2;
            return (
                func[arg - h2] - func[arg + h2] +
                ( func[arg + h]  - func[arg - h] ) * 8
                ) / (h2 * 6);
        }
    }
}

Answer 5

Otro enfoque puede ser aprovechar los métodos de extensiones usando la definición conocida del número derivado y calcular su aproximación en consecuencia.

Como ya se ha mencionado, esto es bastante fácil para un enfoque numérico no simbólico:

public partial static class IEnumerableExtensions
{
    public static IEnumerable<Double> Derivate1<TSource>(this IEnumerable<TSource> source, Func<TSource, Double> selectorX, Func<TSource, Double> selectorY)
    {
        var enumerator = source.GetEnumerator();

        enumerator.Reset();
        enumerator.MoveNext();

        var itemPrevious = enumerator.Current;
        var itemNext = default(TSource);

        while (enumerator.MoveNext())
        {
            itemNext = enumerator.Current;

            var itemPreviousX = selectorX(itemPrevious);
            var itemPreviousY = selectorY(itemPrevious);

            var itemNextX = selectorX(itemNext);
            var itemNextY = selectorY(itemNext);

            var derivative = (itemNextY - itemPreviousY) / (itemNextX - itemPreviousX);

            yield return derivative;

            itemPrevious = itemNext;
        }
    }
}

o si estás más en una moda foreach

public partial static class IEnumerableExtensions
{
     public static IEnumerable<Double> Derivate2<TSource>(IEnumerable<TSource> source, Func<TSource, Double> selectorX, Func<TSource, Double> selectorY)
     {
         var itemPrevious = source.First();

         source = source.Skip(1);

         foreach (var itemNext in source)
         {
             var itemPreviousX = selectorX(itemPrevious);
             var itemPreviousY = selectorY(itemPrevious);

             var itemNextX = selectorX(itemNext);
             var itemNextY = selectorY(itemNext);

             var derivative = (itemNextY - itemPreviousY) / (itemNextX - itemPreviousX);

             yield return derivative;

             itemPrevious = itemNext;
        }
    }
}

Puede refactorizar todo de la siguiente manera:

public static partial class MathHelpers
{
    public static Double Derivate(Double xPrevious, Double xNext, Double yPrevious, Double yNext)
    {
        var derivative = (yNext - yPrevious)/(xNext - xPrevious);

        return derivative;
    }
}

public static class IEnumerableExtensions
{
     public static IEnumerable<Double> Derivate<TSource>(IEnumerable<TSource> source, Func<TSource, Double> selectorX, Func<TSource, Double> selectorY)
     {
         var itemPrevious = source.First();

         source = source.Skip(1);

         foreach (var itemNext in source)
         {
             var derivative = MathHelpers.Derivate(selectorX(itemPrevious), selectorX(itemNext), selectorY(itemPrevious), selectorY(itemNext));

             yield return derivative;

             itemPrevious = itemNext;
        }
    }
}