Numerical Differentiation in IronPython QuickStart Sample

Illustrates how to approximate the derivative of a function in IronPython.
```Python
import numerics

from math import *
from System import Math

# The numerical differentiation classes reside in the
# Extreme.Mathematics.Calculus namespace.
from Extreme.Mathematics.Calculus import *
# Function delegates reside in the Extreme.Mathematics
# namespace.
from Extreme.Mathematics import *

# Illustrates numerical differentiation using the
# FunctionMath class in the Extreme.Mathematics 
# namespace of Extreme Numerics.NET.

# Numerical differentiation is a fairly simple
# procedure. Its accuracy is inherently limited
# because of unavoidable round-off error.
#
# All calculations are performed by static methods
# of the FunctionMath class. All methods are extension
# methods, so they can be applied to the delegates
# directly.

#
# Standard numerical differentiation.
#

# Central differences are the standard way of
# approximating the result of a function.
# For this to work, it must be possible to 
# evaluate the target function on both sides of
# the point where the numerical result is
# requested.

# The function must be provided as a 
# Func<double, double>. For more information about 
# this delegate, see the FunctionDelegates 
# QuickStart Sample.
fCentral = cos

print "Central differences:"
# The actual calculation is performed by the
# CentralDerivative method.
result = FunctionMath.CentralDerivative(fCentral, 1.0)
print "  Result =", result
print "  Actual =", -sin(1.0)
# This method is overloaded. It has an optional
# out parameter that returns an estimate for the
# error in the result.
import clr
estimatedError = clr.Reference[float]()
result = FunctionMath.CentralDerivative(fCentral, 1.0, estimatedError)
print "Estimated error =", estimatedError.Value

#
# Forward and backward differences.
#

# Some functions are not defined everywhere.
# If the result is required on a boundary
# of the domain where it is defined, the central
# differences method breaks down. This also happens
# if the function has a discontinuity close to the
# differentiation point.
# 
# In these cases, either forward or backward 
# differences may be used instead.
#
# Here is an example of a function that may require
# forward differences. It is undefined for
# x < -2:
fForward = lambda x: (x+2) * (x+2) * Math.Sqrt(x+2)
			
# Calculating the derivative using central 
# differences returns NaN (Not a Number):
result = FunctionMath.CentralDerivative(fForward, -2.0, estimatedError)
print "Using central differences may not work:"
print "  Derivative =", result
print "  Estimated error =", estimatedError.Value

# Using the ForwardDerivative method does work:
print "Using forward differences instead:"
result = FunctionMath.ForwardDerivative(fForward, -2.0, estimatedError)
print "  Derivative =", result
print "  Estimated error =", estimatedError
			
# The FBackward function at the end of this file
# is an example of a function that requires
# backward differences for differentiation at
# x = 0.
fBackward = lambda x: 1.0 if x > 0.0 else Math.Sin(x)
print "Using backward differences:"
result = FunctionMath.BackwardDerivative(fBackward, 0.0, estimatedError)
print "  Derivative =", result
print "  Estimated error =", estimatedError

#
# Derivative function
#

# In some cases, it may be useful to have the
# derivative of a function in the form of a 
# Func<double, double>, so it can be passed as
# an argument to other methods. This is very
# easy to do.
print "Using delegates:"
			
# For central differences:
dfCentral = FunctionMath.GetNumericalDifferentiator(fCentral)
print "Central: f'(1) =", dfCentral(1)
			
# For forward differences:
dfForward = FunctionMath.GetForwardDifferentiator(fForward)
print "Forward: f'(-2) =", dfForward(-2)

# For backward differences:
dfBackward = FunctionMath.GetBackwardDifferentiator(fBackward)
print "Backward: f'(0) =", dfBackward(0)
```