Question

Each of the following problems describes an algorithm implemented on a computer satisfying the axioms (13.5) and $(13.7) .$ For each one, state whether the algorithm is backward stable, stable but not backward stable, or unstable, and prove it or at least give a reasonably convincing argument. Be sure to follow the definitions as given in the text. (a) Data: $x \in \mathbb{C} .$ Solution: $2 x,$ computed as $x \oplus x$ (b) Data: $x \in \mathbb{C}$. Solution: $x^{2},$ computed as $x \otimes x$ (c) Data: $x \in \mathbb{C} \backslash\{0\} .$ Solution: $1,$ computed as $x \oplus x .$ (A machine satisfying (13.6) will give exactly the right answer, but our definitions are based on the weaker condition $(13.7) .)$ (d) Data: $x \in \mathbb{C}$. Solution: $0,$ computed as $x \ominus x .$ (Again, a real machine may do better than our definitions based on $(13.7) .)$ (e) Data: none. Solution: $e,$ computed by summing $\sum_{k=0}^{\infty} 1 / k !$ from left to right using $\otimes$ and $\oplus,$ stopping when a summand is reached of magnitude $<\epsilon_{\text {machine }}$ (f) Data: none. Solution: $e,$ computed by the same algorithm as above except with the series summed from right to left. (g) Data: none. Solution: $\pi,$ computed by doing an exhaustive search to find the smallest floating point number $x$ in the interval [3,4] such that $s(x) \otimes$ $s\left(x^{\prime}\right) \leq 0 .$ Here $s(x)$ is an algorithm that calculates $\sin (x)$ stably in the given interval, and $x^{\prime}$ denotes the next floating point number after $x$ in the floating point system.

Name: Problem 1, Chapter 15: Numerical Linear Algebra
Uploaded: 2025-07-01T04:59:51-08:00
Duration: 13 min
Channel: Gabriel Eduok

   Each of the following problems describes an algorithm implemented on a computer satisfying the axioms (13.5) and $(13.7) .$ For each one, state whether the algorithm is backward stable, stable but not backward stable, or unstable, and prove it or at least give a reasonably convincing argument. Be
sure to follow the definitions as given in the text.
(a) Data: $x \in \mathbb{C} .$ Solution: $2 x,$ computed as $x \oplus x$
(b) Data: $x \in \mathbb{C}$. Solution: $x^{2},$ computed as $x \otimes x$
(c) Data: $x \in \mathbb{C} \backslash\{0\} .$ Solution: $1,$ computed as $x \oplus x .$ (A machine satisfying (13.6) will give exactly the right answer, but our definitions are based on the weaker condition $(13.7) .)$
(d) Data: $x \in \mathbb{C}$. Solution: $0,$ computed as $x \ominus x .$ (Again, a real machine may do better than our definitions based on $(13.7) .)$
(e) Data: none. Solution: $e,$ computed by summing $\sum_{k=0}^{\infty} 1 / k !$ from left to right using $\otimes$ and $\oplus,$ stopping when a summand is reached of magnitude
$<\epsilon_{\text {machine }}$
(f) Data: none. Solution: $e,$ computed by the same algorithm as above except with the series summed from right to left. (g) Data: none. Solution: $\pi,$ computed by doing an exhaustive search to find the smallest floating point number $x$ in the interval [3,4] such that $s(x) \otimes$ $s\left(x^{\prime}\right) \leq 0 .$ Here $s(x)$ is an algorithm that calculates $\sin (x)$ stably in the given interval, and $x^{\prime}$ denotes the next floating point number after $x$ in the floating point system.

Numerical Linear Algebra

Lloyd N. Trefethen,… 1st Edition

Chapter 15, Problem 1

Instant Answer

Solved by Expert Gabriel Eduok

07/01/2025

Step 1

Solution: $ 2x $, computed as $ x \oplus x $. - The operation $ x \oplus x $ is a floating-point addition. By the definition of backward stability, we need to check if there exists a $ \tilde{x} $ such that $ \tilde{x} $ is close to $ x $ and \( x Show more…

Show all steps

Thanks for your feedback!

Each of the following problems describes an algorithm implemented on a computer satisfying the axioms (13.5) and $(13.7) .$ For each one, state whether the algorithm is backward stable, stable but not backward stable, or unstable, and prove it or at least give a reasonably convincing argument. Be sure to follow the definitions as given in the text. (a) Data: $x \in \mathbb{C} .$ Solution: $2 x,$ computed as $x \oplus x$ (b) Data: $x \in \mathbb{C}$. Solution: $x^{2},$ computed as $x \otimes x$ (c) Data: $x \in \mathbb{C} \backslash\{0\} .$ Solution: $1,$ computed as $x \oplus x .$ (A machine satisfying (13.6) will give exactly the right answer, but our definitions are based on the weaker condition $(13.7) .)$ (d) Data: $x \in \mathbb{C}$. Solution: $0,$ computed as $x \ominus x .$ (Again, a real machine may do better than our definitions based on $(13.7) .)$ (e) Data: none. Solution: $e,$ computed by summing $\sum_{k=0}^{\infty} 1 / k !$ from left to right using $\otimes$ and $\oplus,$ stopping when a summand is reached of magnitude $<\epsilon_{\text {machine }}$ (f) Data: none. Solution: $e,$ computed by the same algorithm as above except with the series summed from right to left. (g) Data: none. Solution: $\pi,$ computed by doing an exhaustive search to find the smallest floating point number $x$ in the interval [3,4] such that $s(x) \otimes$ $s\left(x^{\prime}\right) \leq 0 .$ Here $s(x)$ is an algorithm that calculates $\sin (x)$ stably in the given interval, and $x^{\prime}$ denotes the next floating point number after $x$ in the floating point system.

Play audio

Feedback

Gabriel Eduok and 52 other subject Chemistry 101 educators are ready to help you.

Ask a new question

Labs

Want to see this concept in action?

NEW

Explore this concept interactively to see how it behaves as you change inputs.

View Labs

Key Concepts

Order of Summation in Series Computation

The order in which operations are performed, especially in the summation of series, can significantly influence the accumulation and cancellation of rounding errors. Summing a series from left to right versus right to left may affect the magnitude of intermediate errors and, consequently, the overall accuracy and stability of the computed result. This concept is important when analyzing algorithms that approximate functions through infinite series.

Algorithm Design in Floating Point Systems

This concept encompasses the strategies and considerations involved in constructing numerical algorithms that operate within the limitations of floating point arithmetic. It includes the choice of methods to minimize error propagation, the impact of machine precision on algorithm performance, and techniques like exhaustive search or alternative summation orders to mitigate instability. Proper design ensures that algorithms remain robust in the face of finite precision constraints.

Error Analysis

Error analysis involves quantifying and understanding how small errors, such as rounding errors in floating point arithmetic, propagate through a computational algorithm. This includes the study of local errors introduced during elementary operations and their cumulative impact on the final result. It is a fundamental tool in assessing both the stability and backward stability of numerical algorithms.

Backward Stability

Backward stability is a stringent measure of algorithmic reliability where the computed result is exactly the correct solution to a nearby problem, with the deviation being within the bounds of round-off errors. In other words, an algorithm is backward stable if its net effect can be interpreted as having solved a slightly perturbed version of the original problem, making it highly reliable under finite precision operations.

Floating Point Arithmetic

This concept involves the rules and properties governing arithmetic operations in a computer system that represents real numbers in a finite way. It includes axioms that characterize how rounding and precision limitations affect results, providing the mathematical framework for analyzing errors in computations. Understanding these properties is crucial for evaluating the behavior and reliability of numerical algorithms under the constraints of finite precision.

Stability of Algorithms

Stability in numerical algorithms refers to the sensitivity of the output to small perturbations in the input or intermediate arithmetic errors. An algorithm is considered stable if the forward error, which is the difference between the computed solution and the true solution, remains bounded when subjected to rounding or small data errors. Stability does not guarantee that the computation is backward stable; it only ensures that errors do not grow uncontrollably.

Recommended Videos

Transcript

00:01 All right, so there's a long question read, and it goes, each of the following problems describe an algorithm implemented on a computer satisfying certain axioms 13 .5 and 13 .7.

00:13 For each one state whether the algorithm is backward stable, stable but not backward stable or unstable, improve it, or at least give a reasonable convincing argument.

00:25 Be sure to follow the definitions as given in a text.

00:29 So i'm just going to go ahead and show you what the algorithms are.

00:40 And then we go from there.

00:44 Okay, so for the first one here, it's going to go a here, where we have 2x computed as x that x, right? so we have essentially the function, you say since that is basically this is a backwards table corresponds to evaluate into x at slightly perturbed inputs as what i wrote down and the point here really is that it computes along via floating point addition right so if you want to take a look at what that might look like we can work our argument here here.

01:34 Yeah, now we can do something along these lines.

01:42 And latex is rendering this a little weird here.

01:45 So i'm going to try doing something here.

01:53 And yeah, so i'm just going to put that there, right? so imagine this is, imagine this to be the case here.

01:59 I'm going to have some things here.

02:00 I'm going to reveal shortly, but i want to take that away here.

02:04 Yeah, clearly you can see.

02:06 That something later on would be back was stable.

02:09 So anyway, this is what i want to show you.

02:11 So if you have this and where the absolute value for delta here is actually something that you, i mean, we could see from this part, right, where the absolute value of delta is as follows.

02:31 So let me also do, i want to do something here.

02:34 I'm going to kind of reduce this.

02:38 You're sticking a lot of space here.

02:41 And then i'll send this to back.

02:42 Okay.

02:43 So if you have this case here when you have delta, less than equal to epsilon here, you would have a backward error here.

02:56 So the result is exactly 2x times 1 plus delta, which is the same as evaluating 2 times, parentheses x times 1 plus delta prime.

03:09 That is, you can interpret the result that's coming from a slightly perturbed input, like i said earlier, right here.

03:16 And the perturbed input would look a little something.

03:19 I hope i can render this well.

03:25 So you would have the perturbed input that looks something like this.

03:30 Let's try to blow this up a little bit to so more visible, legible here.

03:36 So, yeah, this is the point here.

03:40 So, yeah, i'll blow that one up as well here.

03:43 So this is what makes his backwards stable.

03:46 All right, so it's backwards stable.

03:48 Let's go to the next one.

03:50 We have b here.

03:52 And we can, well, this computes x squared via floating point multiplication, right? so for the floating point multiplication, what you're looking at? you're going to be looking at something along these other.

04:08 Lines, right? so this is what you're thinking about right here, something along these line.

04:19 And this is close to the true value, and the result is what you get by squaring x plus, well, x by square x, yeah, a square x, yeah, a square x times 1 plus delta prime squared with you know that delta there so this is what we make it backwards stable okay and again you're talking about some perturped x value here so let me bring that forward here into front there you go so you can just see how that it's looking for c we would also have now this one is a little different here we're going to have it be stable but not backward stable.

05:15 So what are we thinking about here? if i'm going to just get rid of these, let me delete those, and then i can proceed with kind of explaining it.

05:24 So you are computing x over x in floating point, right? that's what you're doing here.

05:31 Now, this is not exactly 1 in general, so the computer result is not exactly correct.

05:38 However, the result is close to 1.

05:41 And so if you interpret it as the following, let me show you that if you have, if you interpret it this way, right? if we interpret it this way, then the error can be small but not necessarily backwards stable.

05:56 So the oppression is not equivalent to, you know, f of x bar for x equal, approximately equal to x bar.

06:03 So it's stable but not backwards stable.

06:07 So what i wrote here is that, you know, what i said here basically is that, you know, what i said here basically is that, but it's near the correct value one, but it's not exactly the value.

06:22 All right, so let me also put this one up a little.

06:26 We can see.

06:27 So again, this is stable, but not backward stable.

06:31 Let's try and see if we can do this a little faster.

06:34 I would have this one zero computed as x.

06:39 All right, so let's do this.

06:41 I'm going to go ahead and, well, e is excited to come out.

06:47 So let's kind of use a little different.

06:50 So under the 13 .7 axiom, what we're thinking about is here, but the thing is this expression is not always the value is to exactly zero, or any reasonable model...

Ace is your personal tutor. It breaks down any question with clear steps so you can learn.

Start Using Ace

Continue solving this problem

Create a free account to:

View full step-by-step solution
Ask follow-up questions with Ace AI
Save progress and study later

Please give Ace some feedback