Differentiation: Static facade class for simple use cases

src/Numerics/Differentiate.cs

@@ -0,0 +1,208 @@
+// <copyright file="Differentiate.cs" company="Math.NET">
+// Math.NET Numerics, part of the Math.NET Project
+// http://numerics.mathdotnet.com
+// http://github.com/mathnet/mathnet-numerics
+// http://mathnetnumerics.codeplex.com
+//
+// Copyright (c) 2009-2015 Math.NET
+//
+// Permission is hereby granted, free of charge, to any person
+// obtaining a copy of this software and associated documentation
+// files (the "Software"), to deal in the Software without
+// restriction, including without limitation the rights to use,
+// copy, modify, merge, publish, distribute, sublicense, and/or sell
+// copies of the Software, and to permit persons to whom the
+// Software is furnished to do so, subject to the following
+// conditions:
+//
+// The above copyright notice and this permission notice shall be
+// included in all copies or substantial portions of the Software.
+//
+// THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND,
+// EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES
+// OF MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND
+// NONINFRINGEMENT. IN NO EVENT SHALL THE AUTHORS OR COPYRIGHT
+// HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY,
+// WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING
+// FROM, OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR
+// OTHER DEALINGS IN THE SOFTWARE.
+// </copyright>
+
+using System;
+using MathNet.Numerics.Differentiation;
+
+namespace MathNet.Numerics
+{
+    /// <summary>
+    /// Numerical Derivative.
+    /// </summary>
+    public static class Differentiate
+    {
+        /// <summary>
+        /// Initialized a NumericalDerivative with the given points and center.
+        /// </summary>
+        public static NumericalDerivative Points(int points, int center)
+        {
+            return new NumericalDerivative(points, center);
+        }
+
+        /// <summary>
+        /// Initialized a NumericalDerivative with the default points and center for the given order.
+        /// </summary>
+        public static NumericalDerivative Order(int order)
+        {
+            var points = order + (order.IsEven() ? 1 : 2);
+            return new NumericalDerivative(points, points/2);
+        }
+
+        /// <summary>
+        /// Evaluates the derivative of a scalar univariate function.
+        /// </summary>
+        /// <param name="f">Univariate function handle.</param>
+        /// <param name="x">Point at which to evaluate the derivative.</param>
+        /// <param name="order">Derivative order.</param>
+        public static double Derivative(Func<double, double> f, double x, int order)
+        {
+            return Order(order).EvaluateDerivative(f, x, order);
+        }
+
+        /// <summary>
+        /// Creates a function handle for the derivative of a scalar univariate function.
+        /// </summary>
+        /// <param name="f">Univariate function handle.</param>
+        /// <param name="order">Derivative order.</param>
+        public static Func<double, double> DerivativeFunc(Func<double, double> f, int order)
+        {
+            return Order(order).CreateDerivativeFunctionHandle(f, order);
+        }
+
+        /// <summary>
+        /// Evaluates the first derivative of a scalar univariate function.
+        /// </summary>
+        /// <param name="f">Univariate function handle.</param>
+        /// <param name="x">Point at which to evaluate the derivative.</param>
+        public static double FirstDerivative(Func<double, double> f, double x)
+        {
+            return Order(1).EvaluateDerivative(f, x, 1);
+        }
+
+        /// <summary>
+        /// Creates a function handle for the first derivative of a scalar univariate function.
+        /// </summary>
+        /// <param name="f">Univariate function handle.</param>
+        public static Func<double, double> FirstDerivativeFunc(Func<double, double> f)
+        {
+            return Order(1).CreateDerivativeFunctionHandle(f, 1);
+        }
+
+        /// <summary>
+        /// Evaluates the second derivative of a scalar univariate function.
+        /// </summary>
+        /// <param name="f">Univariate function handle.</param>
+        /// <param name="x">Point at which to evaluate the derivative.</param>
+        public static double SecondDerivative(Func<double, double> f, double x)
+        {
+            return Order(2).EvaluateDerivative(f, x, 2);
+        }
+
+        /// <summary>
+        /// Creates a function handle for the second derivative of a scalar univariate function.
+        /// </summary>
+        /// <param name="f">Univariate function handle.</param>
+        public static Func<double, double> SecondDerivativeFunc(Func<double, double> f)
+        {
+            return Order(2).CreateDerivativeFunctionHandle(f, 2);
+        }
+
+        /// <summary>
+        /// Evaluates the partial derivative of a multivariate function.
+        /// </summary>
+        /// <param name="f">Multivariate function handle.</param>
+        /// <param name="x">Vector at which to evaluate the derivative.</param>
+        /// <param name="parameterIndex">Index of independent variable for partial derivative.</param>
+        /// <param name="order">Derivative order.</param>
+        public static double PartialDerivative(Func<double[], double> f, double[] x, int parameterIndex, int order)
+        {
+            return Order(order).EvaluatePartialDerivative(f, x, parameterIndex, order);
+        }
+
+        /// <summary>
+        /// Creates a function handle for the partial derivative of a multivariate function.
+        /// </summary>
+        /// <param name="f">Multivariate function handle.</param>
+        /// <param name="parameterIndex">Index of independent variable for partial derivative.</param>
+        /// <param name="order">Derivative order.</param>
+        public static Func<double[], double> PartialDerivativeFunc(Func<double[], double> f, int parameterIndex, int order)
+        {
+            return Order(order).CreatePartialDerivativeFunctionHandle(f, parameterIndex, order);
+        }
+
+        /// <summary>
+        /// Evaluates the first partial derivative of a multivariate function.
+        /// </summary>
+        /// <param name="f">Multivariate function handle.</param>
+        /// <param name="x">Vector at which to evaluate the derivative.</param>
+        /// <param name="parameterIndex">Index of independent variable for partial derivative.</param>
+        public static double FirstPartialDerivative(Func<double[], double> f, double[] x, int parameterIndex)
+        {
+            return PartialDerivative(f, x, parameterIndex, 1);
+        }
+
+        /// <summary>
+        /// Creates a function handle for the first partial derivative of a multivariate function.
+        /// </summary>
+        /// <param name="f">Multivariate function handle.</param>
+        /// <param name="parameterIndex">Index of independent variable for partial derivative.</param>
+        public static Func<double[], double> FirstPartialDerivativeFunc(Func<double[], double> f, int parameterIndex)
+        {
+            return PartialDerivativeFunc(f, parameterIndex, 1);
+        }
+
+        /// <summary>
+        /// Evaluates the partial derivative of a bivariate function.
+        /// </summary>
+        /// <param name="f">Bivariate function handle.</param>
+        /// <param name="x">First argument at which to evaluate the derivative.</param>
+        /// <param name="y">Second argument at which to evaluate the derivative.</param>
+        /// <param name="parameterIndex">Index of independent variable for partial derivative.</param>
+        /// <param name="order">Derivative order.</param>
+        public static double PartialDerivative2(Func<double, double, double> f, double x, double y, int parameterIndex, int order)
+        {
+            return Order(order).EvaluatePartialDerivative(array => f(array[0], array[1]), new[] { x, y }, parameterIndex, order);
+        }
+
+        /// <summary>
+        /// Creates a function handle for the partial derivative of a bivariate function.
+        /// </summary>
+        /// <param name="f">Bivariate function handle.</param>
+        /// <param name="parameterIndex">Index of independent variable for partial derivative.</param>
+        /// <param name="order">Derivative order.</param>
+        public static Func<double, double, double> PartialDerivative2Func(Func<double, double, double> f, int parameterIndex, int order)
+        {
+            var handle = Order(order).CreatePartialDerivativeFunctionHandle(array => f(array[0], array[1]), parameterIndex, order);
+            return (x, y) => handle(new[] { x, y });
+        }
+
+        /// <summary>
+        /// Evaluates the first partial derivative of a bivariate function.
+        /// </summary>
+        /// <param name="f">Bivariate function handle.</param>
+        /// <param name="x">First argument at which to evaluate the derivative.</param>
+        /// <param name="y">Second argument at which to evaluate the derivative.</param>
+        /// <param name="parameterIndex">Index of independent variable for partial derivative.</param>
+        public static double FirstPartialDerivative2(Func<double, double, double> f, double x, double y, int parameterIndex)
+        {
+            return PartialDerivative2(f, x, y, parameterIndex, 1);
+        }
+
+        /// <summary>
+        /// Creates a function handle for the first partial derivative of a bivariate function.
+        /// </summary>
+        /// <param name="f">Bivariate function handle.</param>
+        /// <param name="parameterIndex">Index of independent variable for partial derivative.</param>
+        public static Func<double, double, double> FirstPartialDerivative2Func(Func<double, double, double> f, int parameterIndex)
+        {
+            return PartialDerivative2Func(f, parameterIndex, 1);
+        }
+    }
+}

src/Numerics/Differentiation/FiniteDifferenceCoefficients.cs

@@ -84,7 +84,7 @@ namespace MathNet.Numerics.Differentiation
             if (order >= _coefficients.Length)
                 throw new ArgumentOutOfRangeException("order", "Maximum difference order is points-1.");
 
-            // Return proper row 
+            // Return proper row
             var columns = _coefficients[center].GetLength(1);
             var array = new double[columns];
             for (int i = 0; i < columns; ++i)

src/Numerics/Differentiation/NumericalDerivative.cs

@@ -63,7 +63,7 @@ namespace MathNet.Numerics.Differentiation
     /// <summary>
     /// Class to evaluate the numerical derivative of a function using finite difference approximations.
     /// Variable point and center methods can be initialized <seealso cref="FiniteDifferenceCoefficients"/>.
-    /// This class can also be used to return function handles (delagates) for a fixed derivative order and variable.
+    /// This class can also be used to return function handles (delegates) for a fixed derivative order and variable.
     /// It is possible to evaluate the derivative and partial derivative of univariate and multivariate functions respectively.
     /// </summary>
     public class NumericalDerivative
@@ -94,7 +94,7 @@ namespace MathNet.Numerics.Differentiation
         public double BaseStepSize
         {
             get { return _baseStepSize; }
-            set 
+            set
             {
                 //Base 2 yields more accurate results...
                 var p = Math.Log(Math.Abs(value)) / Math.Log(2);

src/Numerics/Integrate.cs

@@ -34,7 +34,7 @@ using MathNet.Numerics.Integration;
 namespace MathNet.Numerics
 {
     /// <summary>
-    /// Numeric Integration (Quadrature).
+    /// Numerical Integration (Quadrature).
     /// </summary>
     public static class Integrate
     {

src/Numerics/Numerics.csproj

@@ -80,6 +80,7 @@
     <Reference Include="System.Numerics" />
   </ItemGroup>
   <ItemGroup>
+    <Compile Include="Differentiate.cs" />
     <Compile Include="Differentiation\FiniteDifferenceCoefficients.cs" />
     <Compile Include="Differentiation\NumericalDerivative.cs" />
     <Compile Include="Differentiation\NumericalHessian.cs" />