Numerical Differentiation - Keystone Mining Post

HOME › AREAS OF EXPERTISE #2 › Numerical Difference › ~ Forward Difference

Numerical Difference

~ Forward Difference

~ Backward Difference

~ Richardson Extrap

FORWARD DIFFERENCE METHOD

IMPLEMENTATION

IMPLEMENTATION
Forward Difference Method

What follows is the implementation of forward numerical derivatives using the equations derived in the previous tab. We created a new class - Differentiation - to run the test but we did not include the code listing.

public delegate double Function(double x);
private const double badResult = double.NaN;

public static double Forward1(Function f, double x, double h)
{
    h = (h == 0) ? 0.01 : h;
    return (-3 * f(x) + 4 * f(x + h) - f(x + 2 + h)) / 2 / h;
}

public static double Forward1(double[] yarray, int yindex, double h)
{
    if (yarray == null || yarray.Length < 3 || yindex < 0 ||
      yindex > yarray.Length - 3 || h == 0)
      return badResult;
    return (-3 * yarray[yindex] + 4 * yarray[yindex + 1] -
      yarray[yindex + 2]) / 2 / h;
}

public static double Forward2(Function f, double x, double h)
{
    h = (h == 0) ? 0.01 : h;
    return (2 * f(x) - 5 * f(x + h) + 4 * f(x + 2 * h) - f(x + 3 * h)) / h / h;
}

public static double Forward2(double[] yarray, int yindex, double h)
{
    if (yarray == null || yarray.Length < 4 || yindex < 0 ||
      yindex > yarray.Length - 4 || h == 0)
      return badResult;
    return (2 * yarray[yindex] - 5 * yarray[yindex + 1] +
      4 * yarray[yindex + 2] - yarray[yindex + 3]) / h / h;
}

In the above implementation, each derivative has two overloaded methods: one for the function and another for the array of data values. In order to calculate derivatives for a function, one has to pass a delegate function f(x), the value of x at which the derivative is computed, and the increment h as input parameters.

On the other hand, in order to calculate derivatives for an array of data values, each method has input parameters which pass the yarray values, the index called yindex which specifies the location at which the derivative is computed, and the increment h. Here, the increment parameter is the value used to generate the function values.

Wrote and added a new method to the "Differentiation class". A sample of execution is shown on the next tab.

TESTING

Testing the Forward Difference Method

In order to test the Forward Difference method, a new static method has been added to show how to calculate the first four derivatives for f(x) = cos x. The TestForwardMethod() method has been written, added and executed:

►

           static void TestForwardMethod();
              {
                 double h = 0.1;
                 double[] yarray=new double[10];
// create yarray:
                 for (int i = 0; i < 10; i++)
                    yarray[i] = f(i * h);
// Calculate derivatives for function:
                     double dy = Differentiation.Forward1(f, 0.3, h);
                     listBox1.Items.Add("f'(x) = " + dy.ToString());
                     dy = Differentiation.Forward2(f, 0.3, h);
                     listBox1.Items.Add("f''(x) = " + dy.ToString());
                     dy = Differentiation.Forward3(f, 0.3, h);
                     listBox1.Items.Add("f'''(x) = " + dy.ToString());
                     dy = Differentiation.Forward4(f, 0.3, h);
                     listBox1.Items.Add("f''''(x) = " + dy.ToString());
// Calculate derivatives for array values:
                 foreach (double y1 in yarray)
                     listBox2.Items.Add(" " + y1.ToString());
                     dy = Differentiation.Forward1(yarray, 3, h);
                     listBox3.Items.Add("y' = " + dy.ToString());
                     dy = Differentiation.Forward2(yarray, 3, h);
                     listBox3.Items.Add("y'' = " + dy.ToString());
                     dy = Differentiation.Forward3(yarray, 3, h);
                     listBox3.Items.Add("y''' = " + dy.ToString());
                     dy = Differentiation.Forward4(yarray, 3, h);
                     listBox3.Items.Add("y'''' = " + dy.ToString());
                     this.Text = "Forward Difference Method / KeystoneMiningPost";
              }
           static double f(double x)
              {
              return Math.Cos(x);
              }

Results are shown below.

METHODS
Forward Difference Method

The forward finite difference can be obtained from the equation shown under the "Overview - Numerical Differentiation" tab. The first four derivatives of the function f(x) are given by the following formulas:

f'(x) = f(x + h) - f(x)
                 h
f''(x) = f(x + 2h) - 2f(x + h) + f(x)
                      h²
f'''(x) = f(x + 3h) - 3f(x + 2h) + 3(f + h) - f(x)
                            h³
f⁽⁴⁾(x) = f(x + 4h) - 4f(x + 3h) + 6f(x + 2h) - 4f(x + h) + f(x)
                                    h⁴

The above equations are usually not used to compute derivatives because they have a large truncation error (order of O(h)). The common practice is to use expressions of O(h²). To obtain forward difference formulas of this order, it is necessary to retain more terms in the Taylor series. Below are listed the results (without derivations):

f'(x) = -3f(x) + 4f(x + h) - f(x + 2h)
                     2h
f''(x) = 2f(x) - 5f(x + h) + 4f(x + 2h) - f(x +3h)
                             h²
f'''(x) = -5f(x) + 18f(x + h) - 24f(x + 2h) + 14f(x +3h) - 3f(x +4h)
                                      2h³
f⁽⁴⁾(x) = 3f(x) - 14f(x + h) + 26f(x + 2h) - 24f(x +3h) + 11f(x +4h) - 2f(x + 5h)
                                                  h⁴

These equations will be used to implement the Forward Difference Method as shown in the next tab. It should be noted that many methods exist to accomplish similar results with varying degrees of accuracy, such as, Backward Difference Method, Central Difference Method, Extended Central Difference Method, Richardson Extrapolation, Derivatives by Interpolation and others.