Question

Experience overflow in a function. When an object (ball, car, airplane) moves through the air, there is a very, very thin layer of air close to the object's surface where the air velocity varies dramatically \(^{18}\), from the same value as the velocity of the object at the object's surface to zero a few centimeters away. The change in velocity is quite abrupt and can be modeled by the functiion $$ v(x)=\frac{1-e^{x / \mu}}{1-e^{1 / \mu}} $$ where \(x=1\) is the object's surface, and \(x=0\) is some distance away where one cannot notice any wind velocity \(v\) because of the passing object \((v=0)\). The vind velocity coincides with the velocity of the object at \(x=1\), here set to \(v=1\). The parameter \(\mu\) is very small and related to the viscosity of air. With a small value of \(\mu\), it becomes difficult to calculate \(v(x)\) on a computer. Make a function \(v(x, m u=1 E-6\), exp=math.exp) for calculating the formula for \(v(x)\) using exp as a possibly user-given exponentional function. Let the v function return the nominator and denominator in the formula as well as the fraction (result). Call the v function for various \(\mathrm{x}\) values between 0 and 1 in a for loop, let mu be \(1 \mathrm{E}-3\), and have an inner for loop over two different exp functions: math. exp and numpy. exp. The output will demonstrate how the denominator is subject to overflow and how difficult it is to calculate this function on a computer. Also plot \(v(x)\) for \(\mu=1,0.01,0.001\) on \([0,1]\) using 10,000 points to see what the function looks like. Name of program file: boundary_layer_func1.py.

Short answer

The function 'v(x)' is defined for velocity and its implementation reveals computational difficulties at small values of \( \mu \) especially with different exp functions.

Step-by-step solution

Define the Function

Start by defining the function `v(x, mu=1E-6, exp=math.exp)` in Python. This function will calculate the velocity based on the given formula. The function should return three values: the numerator, denominator, and the velocity `v(x)`. Use `exp` to compute the exponential expressions.

Implement the Formula

Inside the function `v(x)`, calculate the numerator as `1 - exp(x / mu)` and the denominator as `1 - exp(1 / mu)`. Then compute the fraction (velocity) by dividing the numerator by the denominator, i.e., `fraction = numerator / denominator`.

Setup the Iteration for Different x Values

Create a loop to iterate over various `x` values between 0 and 1. You can use `numpy.linspace(0, 1, number_of_points)` to generate the values for `x`. In this problem, `number_of_points` can be something like 10000 for a smooth plot.

Test with Different exp Functions

Within the loop for `x`, create an inner loop for two different exponential functions: `math.exp` and `numpy.exp`. Call the function `v(x, mu=1E-3, exp=chosen_exp_function)` using each of these functions.

Plot the Function for Various mu Values

Generate plots for `v(x)` with different values of `mu`: `1`, `0.01`, and `0.001`. For each `mu`, create a separate run of the loop with `x` values, and store the results of `v(x)` for plotting. Use a plotting library like `matplotlib` to visualize `v(x)` over the range `[0, 1]`.

Key concepts

Numerical Stability

Numerical stability is a significant concept in computational mathematics, particularly when dealing with algorithms that involve very small or very large numbers. In the given exercise, the function for modeling air velocity changes shows how tricky numerical calculations can become. When the parameter \( \mu \) is very small, it can lead to large exponentials, causing an overflow problem in the expression \( 1 - e^{1/\mu} \). This phenomenon occurs because of the limits of floating-point representation in computers, which may not handle extremely large or small numbers well.
Understanding numerical stability helps in designing algorithms that minimize the effect of rounding errors and prevent overflow. Techniques such as scaling or using logarithmic transformations can sometimes be applied to improve stability. For instance, in this exercise, using the exponential functions wisely and testing them under different conditions allows revealing the instability issues with computation for very small values of \( \mu \). This approach enlightens students about the practical constraints in computational mathematics.
To summarize, numerical stability is about ensuring that small errors in computation do not lead to significant inaccuracies in results. In the world of algorithm design and computational mathematics, keeping a check on numerical stability is crucial.

Exponential Functions

Exponential functions play a pivotal role in this exercise as they are used to model rapid changes in air velocity near moving objects. The main feature of an exponential function, such as \( e^{x} \), is its rapid rate of increase or decrease, which provides a good model for phenomena with abrupt transitions, like those in fluid dynamics.
In the function \( v(x) = \frac{1 - e^{x/\mu}}{1 - e^{1/\mu}} \), both the numerator and the denominator incorporate exponential terms. These terms are sensitive to the parameter \( \mu \). A smaller \( \mu \) increases the rate of change, potentially leading to computational difficulties, such as overflow, when executed on a computer. By testing different exponential implementations (like `math.exp` and `numpy.exp`), one can observe how these implementations handle large or small exponentials, highlighting their strengths and weaknesses.
In computational mathematics, understanding how exponential functions operate can aid in choosing the right library or function for specific tasks, especially when precision and computational limits are a concern.

Plotting with Matplotlib

Plotting functions with `matplotlib` offers a visual insight into the behavior of the model. In this exercise, plotting \( v(x) \) for different \( \mu \) values allows us to visualize how the air velocity transitions from the object's surface outwards.
`Matplotlib` is a powerful Python library that lets you create a wide range of graphs and plots. To use it effectively, you typically start by importing the library and then creating a range of data points, often using `numpy` to produce evenly spaced values over a specified range. In our case, plotting 10,000 points between 0 and 1 provides a detailed curve reflecting the changes in velocity.
Visualizing these plots for multiple \( \mu \) values \([1, 0.01, 0.001]\) helps in understanding the influence of the parameter on the appearance of the boundary layer. Variations in the plot demonstrate how the transition zone in air velocity evolves with \( \mu \), thus making the theoretical understanding of the function more tangible. `Matplotlib` not only helps in representing the data but also in offering an excellent platform for comparing results visually.

Python Programming

Python is an incredibly versatile language, ideal for computational mathematics thanks to its readability and wide array of libraries. In this exercise, Python is employed to calculate, test, and visualize the function for air velocity changes across an object's surface.
Defining the function `v(x, mu=1E-6, exp=math.exp)` in Python allows for flexibility and reusability. It requires careful coding to manage issues like overflow and ensures the function returns the numerator, denominator, and velocity as expected. Python's `math` and `numpy` libraries provide the foundation for handling exponentials, where `numpy` can be more efficient for array operations.
Creating loops and testing different exponential functions in Python showcases the language's capability in iterative computations. It efficiently employs `numpy.linspace()` for generating values and can handle large computations, such as the 10,000 data points required for smooth plotting with `matplotlib`.
Overall, Python stands out for its simplicity and the abundance of libraries it offers, making it an excellent choice for students and professionals alike who engage in computational tasks and data visualization.