How to Calculate and Plot the Derivative of a Function Using Matplotlib and Python ?

Introduction

Calculating and plotting the derivative of a function is a common task in mathematics and data science, particularly for understanding the rate of change in systems. Python provides various libraries to compute derivatives numerically. This article will walk you through two methods of calculating derivatives in Python: using the findiff library and the scipy.misc library (now deprecated). We’ll also cover how to visualize the results using Matplotlib.

A derivative represents the rate of change of a function concerning one of its variables. For simple functions, you can often compute the derivative analytically. However, for more complex functions or datasets where no analytical expression is available, you can use numerical methods to approximate the derivative.

In Python, we can compute these numerical derivatives using libraries such as findiff and scipy.misc. While findiff is a modern and flexible tool, scipy.misc has been deprecated but may still be useful in older projects.

This article covers:
- Installing and using findiff to compute derivatives.
- Using the deprecated scipy.misc for calculating derivatives.
- Plotting both the function and its derivative using matplotlib.

Calculating Derivatives with findiff

Installing findiff

The findiff library provides tools for computing derivatives using finite difference methods. First, you need to install it:

1

pip install findiff

Using findiff to Compute Derivatives

Let’s calculate the derivative of a quadratic function $f(x) = 3x^2 + 2x + 1$ using findiff and plot it alongside the function.

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43

import numpy as np
import matplotlib.pyplot as plt
from findiff import FinDiff

# Define the function f(x) = 3x^2 + 2x + 1
def fonction(x):
    return 3 * x * x + 2 * x + 1

# Generate x values from -2 to 2
x = np.linspace(-2, 2, 100)

# Compute function values f(x)
y = fonction(x)

# Compute the grid spacing dx
dx = x[1] - x[0]

# Create a first derivative operator with respect to x
deriv = FinDiff(0, dx, 1)

# Apply the derivative operator to f(x) to get the derivative f'(x)
dy_dx = deriv(y)

# Plot the original function and its derivative
ax = plt.subplot(111)

plt.plot(x, y, label=r'$f(x)=3x^2+2x+1$', color='red',linewidth=1,linestyle='dashed')
plt.plot(x, dy_dx, label=r"$f'(x)=6x+2$", color='blue',linewidth=1,linestyle='dashed')

# Adding labels and grid
plt.grid(True)

ax.spines['left'].set_position('zero')
ax.spines['right'].set_color('none')
ax.spines['bottom'].set_position('zero')
ax.spines['top'].set_color('none')

plt.axhline(0, color='black',linewidth=0.1)
plt.axvline(0, color='black',linewidth=0.1)
plt.legend()

# Show the plot
plt.show()

Output:

Explanation:

• Function Definition: We define the function $f(x) = 3x^2 + 2x + 1$.
• Grid Spacing: The dx variable represents the spacing between the $x$ values, which is used to calculate finite differences.
• Findiff Operator: The FinDiff(0, dx, 1) object calculates the first derivative of $f(x)$.
• Plotting: The matplotlib library is used to plot the function and its derivative on the same graph for easy comparison.

Advantages of findiff:
- It’s highly flexible and supports higher-order derivatives.
- It handles custom grid spacing easily, making it suitable for scientific simulations.

Calculating Derivative on a single value

findiff cannot be used directly on a single value because it is designed to work on arrays. It requires multiple points to compute the derivative using finite differences, as finite difference methods rely on neighboring values to approximate the slope.

Why findiff Cannot Work with a Single Value:
- Finite difference methods estimate the derivative by evaluating the function at multiple points, which allows them to calculate the rate of change between those points.
- If only a single value is provided, there are no neighboring points to compute the difference, leading to errors like the "Shift slice out of bounds" you encountered.

Here’s how you can properly use findiff with an array of values, avoiding the "out of bounds" error.

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45

import numpy as np
import matplotlib.pyplot as plt
from findiff import FinDiff

# Define the function f(x) = x^2
def fonction(x):
    return x * x

# Generate a range of x values (from 1 to 3, with 100 points in between)
x = np.linspace(1.5, 2.5, 100)

# Compute the function values f(x)
y = fonction(x)

# Compute the grid spacing dx
dx = x[1] - x[0]  # The difference between consecutive x values

# Create a first derivative operator with respect to x
deriv = FinDiff(0, dx, 1)

# Apply the derivative operator to the function values y
dy_dx = deriv(y)

# To get the derivative at a specific x (e.g., x=2), find the closest index:
x_value = 2.0
closest_index = np.argmin(np.abs(x - x_value))

# Print the derivative at x = 2
print(f"The derivative of f(x) = x^2 at x = {x[closest_index]} is approximately {dy_dx[closest_index]}")

# Plot the function and its derivative
plt.plot(x, y, label=r'$f(x)=x^2$', color='red')
plt.plot(x, dy_dx, label=r"$f'(x)=2x$", color='blue')

# Adding title
plt.title('How to Calculate and Plot the Derivative \n of a Function Using Matplotlib and Python ?', fontsize=12)

# Adding labels and grid
plt.grid(True)
plt.axhline(0, color='black', linewidth=1)
plt.axvline(0, color='black', linewidth=1)
plt.legend()

# Show the plot
plt.savefig("python_findiff_single_value.png", bbox_inches='tight',dpi=200)

Output:

1

The derivative of f(x) = x^2 at x = 1.994949494949495 is approximately 3.989898989898987

Explanation:

• Array of x values: We generate a range of x values using np.linspace(1.5, 2.5, 100), which creates 100 points between 1.5 and 2.5.
• Function Values: The function values y = fonction(x) are computed for all points in x.
  Derivative Operator: The FinDiff object computes the derivative across the array of function values.
• Closest Index: To find the derivative at a specific value (like $x=2$), we find the index of the closest value in the x array using np.argmin.

Alternatives for a Single Value:

If you want to compute the derivative at a single value numerically, you can use either:
- Manual finite difference: Directly compute the derivative using the definition of the derivative.
- scipy.misc.derivative (though deprecated, it's suitable for quick single-value derivatives).

Here’s an example of manually computing the derivative at a single point using finite differences:

Example: Manual Finite Difference for a Single Value

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13

def fonction(x):
    return x * x

# The point where we want the derivative
x_value = 2.0

# Small step size for finite difference
h = 1e-6

# Numerical approximation of the derivative using central difference
dy_dx = (fonction(x_value + h) - fonction(x_value - h)) / (2 * h)

print(f"The derivative of f(x) = x^2 at x = {x_value} is approximately {dy_dx}")

Output:

1

The derivative of f(x) = x^2 at x = 2 is approximately 4.000000000115023

Explanation:

• Central Difference Formula: This method uses the values of the function slightly before and after the target point to approximate the derivative:

\begin{equation}
f'(x) \approx \frac{f(x + h) - f(x - h)}{2h}
\end{equation}

• Step Size (h): A small value like 1e-6 is used for accuracy.

Conclusion:
- findiff is designed for arrays and cannot handle single values directly.
- For single values, you can use manual finite differences or other tools like scipy.misc.derivative (deprecated).

Calculating Derivatives with scipy.misc.derivative (Deprecated)

The scipy.misc.derivative function was once widely used to calculate derivatives but has been deprecated. Nevertheless, it is still available in some versions of scipy. Let's use this method to calculate the derivative of the same function.

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37

from scipy import misc  
import numpy as np
import matplotlib.pyplot as plt

# Define the function f(x) = 3x^2 + 2x + 1
def fonction(x):
    return 3 * x * x + 2 * x + 1

# Generate x values from -2 to 2
x = np.linspace(-2, 2, 100)

# Compute function values f(x)
y = fonction(x)

# Compute the derivative at each point using scipy.misc.derivative
yp = [misc.derivative(fonction, xi, dx=1e-6) for xi in x]

# Plot the original function and its derivative
ax = plt.subplot(111)

plt.plot(x, y, label=r'$f(x)=3x^2+2x+1$', color='red',linewidth=1,linestyle='dashed')
plt.plot(x, yp, label=r"$f'(x)=6x+2$", color='blue',linewidth=1,linestyle='dashed')

# Adding labels and grid
plt.grid(True)

ax.spines['left'].set_position('zero')
ax.spines['right'].set_color('none')
ax.spines['bottom'].set_position('zero')
ax.spines['top'].set_color('none')

plt.axhline(0, color='black',linewidth=0.1)
plt.axvline(0, color='black',linewidth=0.1)
plt.legend()

# Show the plot
plt.show()

Output:

Explanation:

• Function Definition: We use the same function $f(x) = 3x^2 + 2x + 1$.
• Calculating Derivative: The misc.derivative function approximates the derivative at each point in the array x using finite differences. Here, we set a small step size dx=1e-6 for higher accuracy.
• Plotting: As before, we use matplotlib to plot the function and its derivative.

Note: scipy.misc.derivative Is Deprecated: The misc module is no longer maintained, and using alternatives like findiff or manually computing finite differences is preferred for modern applications.

Conclusion

In this article, we’ve explored two methods for calculating the derivative of a function in Python:
- findiff: A flexible and powerful library that can handle derivatives of different orders and work with custom grid spacings.
- scipy.misc.derivative: A deprecated function from scipy that still works in older codebases but should be avoided for new projects.

We also visualized both the function and its derivative using matplotlib, which allows for easy comparison of the original function and its rate of change.

If you are working on modern applications or scientific computations, it’s recommended to use findiff due to its flexibility and active development.

References