Математическая функция дифференцирование C #?

голоса
4

Я вижу, что я могу объявить функцию с (скажем)

public double Function(double parameter)

но что, если я хочу взять производную от этой функции?

Задан 16/12/2008 в 22:41
источник пользователем
На других языках...                            


5 ответов

голоса
1

Вы думаете о лямбда-выражения?

В принципе вы можете передать функцию в функцию.

Так что думайте о Sort на объекте. В зависимости от характера объекта поможет определить, как объекты сортируются.

Но вы можете создать родовую функцию сортировки затем передать как сравнивать объекты.

Ответил 16/12/2008 в 22:46
источник пользователем

голоса
0

Если вы написали функцию, она уже была получена.

И учитывая, что что это функция INT, я предполагаю, что вы не имеете в виду определение исчисления «Выведите».

Ответил 16/12/2008 в 22:55
источник пользователем

голоса
7

Если вы думаете о символической манипуляции формул, то вам лучше делать свои выкладки в таких языках, как Maple или Mathematica. Они предназначены для символьных вычислений.

EDIT: Если Maple и Mathematica являются слишком дорогими для вас , то есть и другие варианты. В Википедии есть достаточно полный перечень компьютерной алгебры. http://en.wikipedia.org/wiki/Comparison_of_computer_algebra_systems

Ответил 16/12/2008 в 22:56
источник пользователем

голоса
30

Вы не можете точно рассчитать производную функции с помощью компьютерной программы (если вы не символьная математики ... но это уже совсем другое, гораздо сложнее, тема).

Есть несколько подходов к вычислению числовой производной функции. Наиболее простым является метод по центру три точки:

  • Возьмите небольшое число Л
  • оценивать [f(x+h) - f(x-h)] / 2h
  • Вуаля, приближение Р '(х), причем только две оценки функции

Другой подход заключается в центрированный метод пятибалльной:

  • Возьмите небольшое число Л
  • оценивать [f(x-2h) - 8f(x-h) + 8f(x+h) - f(x+2h)] / 12h
  • Вуаля, наилучшее приближение к Р '(х), но это требует больше вычислений функции

Еще одна тема, как реализовать это с помощью C #. Во-первых, вам нужен делегат, который представляет собой функцию, которая отображает подмножество действительных чисел на другое подмножество действительных чисел:

delegate double RealFunction(double arg);

Тогда вам нужен маршрут, который вычисляет производную:

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);
}

Если вы хотите, объектно-ориентированной реализации, необходимо создать следующие классы:

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);
        }
    }
}
Ответил 16/12/2008 в 23:23
источник пользователем

голоса
1

Другой подход может быть эффективно использовать методы расширения с использованием хорошо известное определение производной числа и вычислить его приближение соответственно.

Как уже упоминалось, это довольно легко для числового подхода не символическая:

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;
        }
    }
}

или , если вы больше в 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;
        }
    }
}

Вы можете реорганизовать все, как показано ниже:

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;
        }
    }
}
Ответил 24/07/2015 в 06:57
источник пользователем

Cookies help us deliver our services. By using our services, you agree to our use of cookies. Learn more