Unraveling the Mystery of Non-Differentiable Functions: A Step-by-Step Guide

Are you tired of encountering strange behavior when trying to plot non-differentiable functions? Do you find yourself scratching your head, wondering why your plots just won’t behave? Fear not, dear reader, for we’re about to embark on a thrilling adventure to demystify this phenomenon. Buckle up, grab a cup of coffee, and get ready to dive into the world of non-differentiable functions!

What are Non-Differentiable Functions, Anyway?

A non-differentiable function is a mathematical function that fails to meet the requirements for differentiability at a specific point or points. In simpler terms, it means the function’s rate of change is undefined or does not exist at certain points. This can lead to some pretty weird and wonderful behavior when trying to plot these functions.

Why Do Non-Differentiable Functions Behave Strangely?

There are several reasons why non-differentiable functions exhibit strange behavior when plotted. Here are a few common culprits:

• Discontinuities**: Non-differentiable functions often have discontinuities, or breaks, in their graphs. This can cause plotting software to freak out and produce weird results.
• Infinite Slopes**: At certain points, the slope of a non-differentiable function might become infinite, leading to plotting software struggling to render the graph accurately.
• Oscillations**: Non-differentiable functions can exhibit rapid oscillations or fluctuations, making it difficult for plotting software to capture the behavior accurately.

Exploring Non-Differentiable Functions with Python

In this section, we’ll use Python to explore some non-differentiable functions and observe their strange behavior. Don’t worry if you’re not a Python expert – we’ll take it one step at a time!

import numpy as np
import matplotlib.pyplot as plt

# Define a non-differentiable function: |x|
def abs_func(x):
    return np.abs(x)

x = np.linspace(-10, 10, 1000)
y = abs_func(x)

plt.plot(x, y)
plt.title("Plot of |x|")
plt.xlabel("x")
plt.ylabel("y")
plt.show()

Run the code above, and you should see a plot of the absolute value function, which is a classic non-differentiable function. Notice how the plot exhibits a sharp “V” shape at x = 0, where the function is not differentiable.

The Weierstrass Function: A Notorious Non-Differentiable Function

The Weierstrass function is a famous example of a non-differentiable function. It’s defined as:

# Define the Weierstrass function
def weierstrass_func(x, a=0.5, b=13.82):
    return np.sum([a**n * np.cos(b**n * x * np.pi) for n in range(100)])

x = np.linspace(-10, 10, 1000)
y = weierstrass_func(x)

plt.plot(x, y)
plt.title("Plot of the Weierstrass Function")
plt.xlabel("x")
plt.ylabel("y")
plt.show()

Run the code above, and you’ll see a plot of the Weierstrass function, which exhibits some truly bizarre behavior. This function is non-differentiable at every point, making it a great example of just how strange non-differentiable functions can be!

Taming the Beast: Strategies for Plotting Non-Differentiable Functions

Now that we’ve explored some non-differentiable functions, let’s discuss some strategies for plotting them more effectively:

1. Increase the Resolution

One simple way to improve the plot is to increase the resolution of the x-axis. This can help capture more detail and smooth out the plot:

x = np.linspace(-10, 10, 10000)  # Increase the resolution to 10,000 points
y = abs_func(x)

plt.plot(x, y)
plt.title("Plot of |x| with Higher Resolution")
plt.xlabel("x")
plt.ylabel("y")
plt.show()

2. Use a Smaller Axis Range

Sometimes, the strange behavior of non-differentiable functions can be due to the large range of the x-axis. Try reducing the axis range to focus on the area of interest:

x = np.linspace(-1, 1, 1000)  # Reduce the axis range to [-1, 1]
y = abs_func(x)

plt.plot(x, y)
plt.title("Plot of |x| with Smaller Axis Range")
plt.xlabel("x")
plt.ylabel("y")
plt.show()

3. Use a Logarithmic Scale

For functions that exhibit rapid oscillations or growth, using a logarithmic scale can help to reduce the noise and reveal more detail:

x = np.logspace(-1, 1, 1000)  # Use a logarithmic scale
y = abs_func(x)

plt.loglog(x, y)
plt.title("Plot of |x| with Logarithmic Scale")
plt.xlabel("x")
plt.ylabel("y")
plt.show()

4. Use a Different Plotting Library

Sometimes, the plotting library itself can be the culprit behind the strange behavior. Try switching to a different library, such as Plotly or Seaborn, to see if the issue persists:

import plotly.graph_objects as go

x = np.linspace(-10, 10, 1000)
y = abs_func(x)

fig = go.Figure(data=[go.Scatter(x=x, y=y)])
fig.update_layout(title="Plot of |x| with Plotly", xaxis_title="x", yaxis_title="y")
fig.show()

Conclusion

In this article, we’ve delved into the fascinating world of non-differentiable functions and explored some strategies for plotting them effectively. Remember, when dealing with non-differentiable functions, it’s essential to be patient, flexible, and willing to try different approaches. By following these tips and tricks, you’ll be well on your way to taming the beast and producing stunning plots that showcase the beauty of these strange and wonderful functions.

Function	Description
|x|	Absolutes value function
Weierstrass Function	A non-differentiable function defined as a sum of infinite cosine series

Happy plotting, and remember to stay curious!

1. Weierstrass Function on Wikipedia
2. Differentiation on MathIsFun
3. Matplotlib Plot API

Frequently Asked Question

Get ready to dive into the world of non-differentiable functions and unravel the mysteries of strange behavior in plotting!