FunctionMath.Derivative Method

public static double Derivative(
	this Func<double, double> targetFunction,
	double x
)

<ExtensionAttribute>
Public Shared Function Derivative ( 
	targetFunction As Func(Of Double, Double),
	x As Double
) As Double

public:
[ExtensionAttribute]
static double Derivative(
	Func<double, double>^ targetFunction, 
	double x
)

[<ExtensionAttribute>]
static member Derivative : 
        targetFunction : Func<float, float> * 
        x : float -> float 

Parameters

targetFunction  Func<Double, Double>

A delegate that represents a function of one variable that specifies the function to differentiate.

x  Double

The point at which to evaluate the derivative.

Return Value

Usage Note

public static double Derivative(
	this Func<double, double> targetFunction,
	double x,
	DifferencesDirection direction
)

<ExtensionAttribute>
Public Shared Function Derivative ( 
	targetFunction As Func(Of Double, Double),
	x As Double,
	direction As DifferencesDirection
) As Double

public:
[ExtensionAttribute]
static double Derivative(
	Func<double, double>^ targetFunction, 
	double x, 
	DifferencesDirection direction
)

[<ExtensionAttribute>]
static member Derivative : 
        targetFunction : Func<float, float> * 
        x : float * 
        direction : DifferencesDirection -> float 

Parameters

targetFunction  Func<Double, Double>

A delegate that represents a function of one variable that specifies the function to differentiate.

x  Double

The point at which to evaluate the derivative.

direction  DifferencesDirection

A DifferencesDirection that specifies the interval to be used for differentiation.

Return Value

Usage Note

This method is useful when the targetFunction is not defined or is discontinuous on either side of x.

If the function is badly behaved on the left, you can set direction to Forward, and the function will only be evaluated at x and to the right of x. Passing Forward causes the function to be evaluated at x and points to the left of x.

If the function is well-behaved on both sides, you should use Central, since that will, in general, yield better results. This is also the default when the direction parameter is omitted.

public static double Derivative(
	this Func<double, double> targetFunction,
	double x,
	out double error
)

<ExtensionAttribute>
Public Shared Function Derivative ( 
	targetFunction As Func(Of Double, Double),
	x As Double,
	<OutAttribute> ByRef error As Double
) As Double

public:
[ExtensionAttribute]
static double Derivative(
	Func<double, double>^ targetFunction, 
	double x, 
	[OutAttribute] double% error
)

[<ExtensionAttribute>]
static member Derivative : 
        targetFunction : Func<float, float> * 
        x : float * 
        error : float byref -> float 

Parameters

targetFunction  Func<Double, Double>

A delegate that represents a function of one variable that specifies the function to differentiate.

x  Double

The point at which to evaluate the derivative.

error  Double

On return, an estimate for the error in the derivative.

Return Value

Usage Note

public static double Derivative(
	this Func<double, double> targetFunction,
	double x,
	DifferencesDirection direction,
	out int evaluationsNeeded
)

<ExtensionAttribute>
Public Shared Function Derivative ( 
	targetFunction As Func(Of Double, Double),
	x As Double,
	direction As DifferencesDirection,
	<OutAttribute> ByRef evaluationsNeeded As Integer
) As Double

public:
[ExtensionAttribute]
static double Derivative(
	Func<double, double>^ targetFunction, 
	double x, 
	DifferencesDirection direction, 
	[OutAttribute] int% evaluationsNeeded
)

[<ExtensionAttribute>]
static member Derivative : 
        targetFunction : Func<float, float> * 
        x : float * 
        direction : DifferencesDirection * 
        evaluationsNeeded : int byref -> float 

Parameters

targetFunction  Func<Double, Double>

A delegate that represents a function of one variable that specifies the function to differentiate.

x  Double

The point at which to evaluate the derivative.

direction  DifferencesDirection

A DifferencesDirection that specifies the interval to be used for differentiation.

evaluationsNeeded  Int32

On exit, contains the number of function evaluations needed to evaluate the derivative.

Return Value

Usage Note

This method is useful when the targetFunction is not defined or is discontinuous on either side of x.

If the function is badly behaved on the left, you can set direction to Forward, and the function will only be evaluated at x and to the right of x. Passing Forward causes the function to be evaluated at x and points to the left of x.

If the function is well-behaved on both sides, you should use Central, since that will, in general, yield better results. This is also the default when the direction parameter is omitted.

public static double Derivative(
	this Func<double, double> targetFunction,
	double x,
	int order = 1,
	DifferencesDirection direction = DifferencesDirection.Central,
	int accuracyOrder = 2,
	bool adaptive = false,
	double xMin = -1.79769313486232E+308,
	double xMax = 1.79769313486232E+308,
	double noiseFactor = 10
)

<ExtensionAttribute>
Public Shared Function Derivative ( 
	targetFunction As Func(Of Double, Double),
	x As Double,
	Optional order As Integer = 1,
	Optional direction As DifferencesDirection = DifferencesDirection.Central,
	Optional accuracyOrder As Integer = 2,
	Optional adaptive As Boolean = false,
	Optional xMin As Double = -1.79769313486232E+308,
	Optional xMax As Double = 1.79769313486232E+308,
	Optional noiseFactor As Double = 10
) As Double

public:
[ExtensionAttribute]
static double Derivative(
	Func<double, double>^ targetFunction, 
	double x, 
	int order = 1, 
	DifferencesDirection direction = DifferencesDirection::Central, 
	int accuracyOrder = 2, 
	bool adaptive = false, 
	double xMin = -1.79769313486232E+308, 
	double xMax = 1.79769313486232E+308, 
	double noiseFactor = 10
)

[<ExtensionAttribute>]
static member Derivative : 
        targetFunction : Func<float, float> * 
        x : float * 
        ?order : int * 
        ?direction : DifferencesDirection * 
        ?accuracyOrder : int * 
        ?adaptive : bool * 
        ?xMin : float * 
        ?xMax : float * 
        ?noiseFactor : float 
(* Defaults:
        let _order = defaultArg order 1
        let _direction = defaultArg direction DifferencesDirection.Central
        let _accuracyOrder = defaultArg accuracyOrder 2
        let _adaptive = defaultArg adaptive false
        let _xMin = defaultArg xMin -1.79769313486232E+308
        let _xMax = defaultArg xMax 1.79769313486232E+308
        let _noiseFactor = defaultArg noiseFactor 10
*)
-> float 

Parameters

targetFunction  Func<Double, Double>

A delegate that represents a function of one variable that specifies the function to differentiate.

x  Double

The point at which to evaluate the derivative.

order  Int32  (Optional)

The order of the derivative.

direction  DifferencesDirection  (Optional)

Optional. The direction in which to compute the finite differences. The default is central differences.

accuracyOrder  Int32  (Optional)

Optional. The accuracy order of the finite difference method. The default is 2.

adaptive  Boolean  (Optional)

Optional. If true, the step size is computed based on the function values around the points where the function's derivative is requested. If false (the default), a default step size is used.

xMin  Double  (Optional)

Optional. The smallest value for which the function may be evaluated. The default is MinValue.

xMax  Double  (Optional)

Optional. The largest value for which the function may be evaluated. The default is MaxValue.

noiseFactor  Double  (Optional)

Optional. An estimate for the noise in the function values relative to the machine precision. The default is 10.

Return Value

Usage Note

Reference