To install click the Add extension button. That's it.

The source code for the WIKI 2 extension is being checked by specialists of the Mozilla Foundation, Google, and Apple. You could also do it yourself at any point in time.

4,5
Kelly Slayton
Congratulations on this excellent venture… what a great idea!
Alexander Grigorievskiy
I use WIKI 2 every day and almost forgot how the original Wikipedia looks like.
Live Statistics
English Articles
Improved in 24 Hours
Languages
Recent
Show all languages
What we do. Every page goes through several hundred of perfecting techniques; in live mode. Quite the same Wikipedia. Just better.
.
Leo
Newton
Brights
Milds

Round-off error

A roundoff error,[1] also called rounding error,[2] is the difference between the result produced by a given algorithm using exact arithmetic and the result produced by the same algorithm using finite-precision, rounded arithmetic.[3] Rounding errors are due to inexactness in the representation of real numbers and the arithmetic operations done with them. This is a form of quantization error.[4] When using approximation equations or algorithms, especially when using finitely many digits to represent real numbers (which in theory have infinitely many digits), one of the goals of numerical analysis is to estimate computation errors.[5] Computation errors, also called numerical errors, include both truncation errors and roundoff errors.

When a sequence of calculations with an input involving roundoff error are made, errors may accumulate, sometimes dominating the calculation. In ill-conditioned problems, significant error may accumulate.[6]

In short, there are two major facets of roundoff errors involved in numerical calculations[7]:

1. Digital computers have magnitude and precision limits on their ability to represent numbers.
2. Certain numerical manipulations are highly sensitive to roundoff errors. This can result from both mathematical considerations as well as from the way in which computers perform arithmetic operations.

• 1/5
Views:
48 371
11 975
991 076
230 344
1 541
• ✪ Round off Error: Sources of Error
• ✪ Rounding and Truncation Errors
• ✪ Math Antics - Rounding
• ✪ Excel formula tutorial: Working with ROUND, ROUNDUP, and ROUNDDOWN | lynda.com
• ✪ MATLAB Programming Tutorial #09 Round-Off Errors & Iterative Methods

Transcription

. . . In this segment we're going to talk about round-off errors. There are several possibilities of error whenever you're going to use numerical methods, but we want to concentrate here on just two errors, one is the round-off error and the other is the truncation error. So those are the sources of error which we are going to talk about, because those are the ones which are coming from something on which you may or may not have as much control as other errors, like for example if you have made a mistake in programming, or if your logic is wrong, those are not the kind of errors which we are talking about when we talk about numerical methods. So you're going to have two sources of error, which you are going to have.|One is round-off error and the other one is called truncation error. . And let's go ahead and concentrate on what round-off error is.|Now round-off error is defined as follows, it is basically the error which comes from . . . so error created due to approximate representation of numbers. . So the round-off error is simply the error created by the approximate representation of numbers, because in a computer you'll be able to only represent a number only so approximately.|For example, if you have a number like 1 divided by 3, and you had a six significant digit computer let's suppose in the decimal notation, then this can be only approximated as 0.333333 . . . and six, there's another 3 here.|So you're seeing that already a simple number, a simple rational number like 1 divided by 3 cannot be written exactly in the decimal format.|So the amount of round-off error which you are getting here is the difference between the value of 1 divided by 3 and the value of 0.333333. So in this case, this error is 0.0000003333 and so on and so forth. You're going to get similar round-off errors from other numbers also, like, you may have pi, that also cannot be represented exactly, even in a decimal format, and then square root of 2, things like that. So you're finding out there are many, many numbers, individual numbers, like 1 divided by 3, or pi, or square root of 2, which cannot be represented exactly in a computer. So that's why this creates the round-off error, the round-off error is the difference between what you want to, what you want to be able to approximate, of what you want to be able to denote, and what you are able to get as its approximation. So that's the, that's what we call as round-off error. So that's the end of this particular segment here. . . .

Representation error

The error introduced by attempting to represent a number using a finite string of digits is a form of roundoff error called representation error.[8] Here are some examples of representation error in decimal representations:

Notation Representation Approximation Error
1/7 0.142 857 0.142 857 0.000 000 142 857
ln 2 0.693 147 180 559 945 309 41...   0.693 147 0.000 000 180 559 945 309 41...
log10 2 0.301 029 995 663 981 195 21...   0.3010 0.000 029 995 663 981 195 21...
32 1.259 921 049 894 873 164 76...   1.25992 0.000 001 049 894 873 164 76...
2 1.414 213 562 373 095 048 80...   1.41421 0.000 003 562 373 095 048 80...
e 2.718 281 828 459 045 235 36...   2.718 281 828 459 045   0.000 000 000 000 000 235 36...
π 3.141 592 653 589 793 238 46...   3.141 592 653 589 793 0.000 000 000 000 000 238 46...

Increasing the number of digits allowed in a representation reduces the magnitude of possible roundoff errors, but any representation limited to finitely many digits will still cause some degree of roundoff error for uncountably many real numbers. Additional digits used for intermediary steps of a calculation are known as guard digits.[9]

Rounding multiple times can cause error to accumulate.[10] For example, if 9.945309 is rounded to two decimal places (9.95), then rounded again to one decimal place (10.0), the total error is 0.054691. Rounding 9.945309 to one decimal place (9.9) in a single step introduces less error (0.045309). This commonly occurs when performing arithmetic operations (See Loss of Significance).

Floating-point number system

Compared with the fixed-point number system, the  floating-point number system is more efficient in representing real numbers so it is widely used in modern computers. While the real numbers ${\displaystyle \mathbb {R} }$ are infinite and continuous, a floating-point number system ${\displaystyle F}$ is finite and discrete. Thus, representation error, which leads to roundoff error, occurs under the floating-point number system.

Notation of floating-point number system

A floating-point number system ${\displaystyle F}$ is characterized by ${\displaystyle 4}$ integers:

${\displaystyle \beta }$: base or radix
${\displaystyle p}$: precision
${\displaystyle [L,U]}$: exponent range, where ${\displaystyle L}$ is the lower bound and ${\displaystyle U}$ is the upper bound
• Any ${\displaystyle x\in F}$ has the following form:
${\displaystyle x=\pm (\underbrace {d_{0}.d_{1}d_{2}\ldots d_{p-1}} _{\text{mantissa}})_{\beta }\times \beta ^{\overbrace {E} ^{\text{exponent}}}=\pm d_{0}\times \beta ^{E}+d_{1}\times \beta ^{E-1}+\ldots +d_{p-1}\times \beta ^{E-(p-1)}}$
where ${\displaystyle d_{i}}$ is an integer such that ${\displaystyle 0\leq d_{i}\leq \beta -1}$ for ${\displaystyle i=0,1,\ldots ,p-1}$, and ${\displaystyle E}$ is an integer such that ${\displaystyle L\leq E\leq U}$.

Normalized floating-number system

• A floating-point number system is normalized if the leading digit ${\displaystyle d_{0}}$ is always nonzero unless the number is zero. [3] Since the mantissa is ${\displaystyle d_{0}.d_{1}d_{2}\ldots d_{p-1}}$, the mantissa of a nonzero number in a normalized system satisfies ${\displaystyle 1\leq {\text{ mantissa }}<\beta }$. Thus, the normalized form of a nonzero IEEE floating-point number is ${\displaystyle \pm 1.bb\ldots b\times 2^{E}}$ where ${\displaystyle b\in {0,1}}$. In binary, the leading digit is always ${\displaystyle 1}$ so it is not written out and is called the implicit bit. Then we can get an extra bit of precision so that the roundoff error caused by representation error is reduced.
• Since floating-point number system ${\displaystyle F}$ is finite and discrete, it cannot represent all real numbers which means infinite real numbers can only be approximated by some finite numbers through rounding rules. We denote the floating-point approximation of a given real number ${\displaystyle x}$ by ${\displaystyle fl(x)}$.
• The total number of normalized floating-point numbers is
${\displaystyle 2(\beta -1)\beta ^{p-1}(U-L+1)+1}$, where
${\displaystyle 2}$ counts choice of sign, being positive or negative
${\displaystyle (\beta -1)}$ counts choice of the leading digit
${\displaystyle \beta ^{p-1}}$ counts remaining mantissa
${\displaystyle U-L+1}$ counts choice of exponents
${\displaystyle 1}$ counts the case when the number is ${\displaystyle 0}$.

IEEE standard

We[who?] will focus on the IEEE standard since it is adopted universally after it was established in 1985. In this standard, the base is binary, i.e. ${\displaystyle \beta =2}$, and normalization is used. The IEEE standard stores the sign, exponent, and mantissa in separate fields of a floating point word, each of which has a fixed width (number of bits). The two most commonly used levels of precision for floating-point numbers are single precision and double precision.

Precision Sign (bits) Exponent (bits) Mantissa (bits)
Single 1 8 23
Double 1 11 52

Machine epsilon

Machine epsilon can be used to measure the level of roundoff error in the floating-point number system. Here are two different definitions. [3]

• The Machine epsilon, denoted ${\displaystyle \epsilon _{mach}}$, is the maximum possible absolute relative error in representing a nonzero real number ${\displaystyle x}$ in a floating-point number system.
${\displaystyle \epsilon _{mach}=\max _{x}{\frac {|x-fl(x)|}{|x|}}}$
• The Machine epsilon, denoted ${\displaystyle \epsilon _{mach}}$, is the smallest number ${\displaystyle \epsilon }$ such that ${\displaystyle fl(1+\epsilon )>1}$. Thus, ${\displaystyle fl(1+\delta )=fl(1)=1}$ whenever ${\displaystyle |\delta |<\epsilon _{mach}}$.

Roundoff error under different rounding rules

There are two common rounding rules, round-by-chop and round-to-nearest. The IEEE standard uses round-to-nearest.

• Round-by-chop: The base-${\displaystyle \beta }$ expansion of ${\displaystyle x}$ is truncated after the ${\displaystyle (p-1)^{th}}$ digit.
• This rounding rule is biased because it always moves the result toward zero.
• Round-to-nearest: We set ${\displaystyle fl(x)}$ to the nearest floating-point number to ${\displaystyle x}$. When there is a tie, we use the floating-point number whose last stored digit is even.
• For IEEE standard where the base ${\displaystyle \beta }$ is ${\displaystyle 2}$, this means when there is a tie we round so that the last digit is equal to ${\displaystyle 0}$.
• This rounding rule is more accurate but more computationally expensive.
• Rounding so that the last stored digit is even when there is a tie ensures that we do not round up or down systematically. This is to try to avoid the possibility of an unwanted slow drift in long calculations due simply to a biased rounding.
• The following example illustrates the level of roundoff error under the two rounding rules. [3] The rounding rule, round-to-nearest, leads to less roundoff error in general.
x Round-by-chop Roundoff Error Round-to-nearest Roundoff Error
1.649 1.6 0.049 1.6 0.049
1.650 1.6 0.050 1.6 0.050
1.651 1.6 0.051 1.7 -0.049
1.699 1.6 0.099 1.7 -0.001
1.749 1.7 0.049 1.7 0.049
1.750 1.7 0.050 1.8 -0.050

Calculating roundoff error in IEEE standard

Suppose we use round-to-nearest and IEEE double precision.

• Example: the decimal number ${\displaystyle (9.4)_{10}=(1001.{\overline {0110}})_{2}}$ can be rearranged into
${\displaystyle +1.\underbrace {0010110011001100110011001100110011001100110011001100} _{\text{52 bits}}110\ldots \times 2^{3}}$

Since the ${\displaystyle 53^{rd}}$ bit to the right of the binary point is a ${\displaystyle 1}$ and is followed by other nonzero bits, the round-to-nearest rule requires rounding up, that is, add ${\displaystyle 1}$ bit to the ${\displaystyle 52^{nd}}$ bit. Thus, the normalized floating-point representation in IEEE standard of ${\displaystyle 9.4}$ is

${\displaystyle fl(9.4)=1.0010110011001100110011001100110011001100110011001101\times 2^{3}}$.
• Now we can calculate the roundoff error when representing ${\displaystyle 9.4}$ with ${\displaystyle fl(9.4)}$.

We derived this representation by discarding the infinite tail

${\displaystyle 0.{\overline {1100}}\times 2^{-52}\times 2^{3}=0.{\overline {0110}}\times 2^{-51}\times 2^{3}=0.4\times 2^{-48}}$

from the right tail and then added ${\displaystyle 1\times 2^{-52}\times 2^{3}=2^{-49}}$ in the rounding step.

Then ${\displaystyle fl(9.4)=9.4-0.4\times 2^{-48}+2^{-49}=9.4+(0.2)_{10}\times 2^{-49}}$.
Thus, the roundoff error is ${\displaystyle (0.2\times 2^{-49})_{10}}$.

Measuring roundoff error by using machine epsilon

We can use machine epsilon ${\displaystyle \epsilon _{mach}}$ to measure the level of roundoff error when using the two rounding rules above. Below are the formulas and corresponding proof [3]. The first definition of machine epsilon is used here.

Theorem

1. Round-by-chop: ${\displaystyle \epsilon _{mach}=\beta ^{1-p}}$
2. Round-to-nearest: ${\displaystyle \epsilon _{mach}={\frac {1}{2}}\beta ^{1-p}}$

Proof

Let ${\displaystyle x=d_{0}.d_{1}d_{2}\ldots d_{p-1}d_{p}\ldots \times \beta ^{n}\in \mathbb {R} }$ where ${\displaystyle n\in [L,U]}$, and let ${\displaystyle fl(x)}$ be the floating-point representation of ${\displaystyle x}$. Since we are using round-by-chop, we have that {\displaystyle {\begin{aligned}{\frac {|x-fl(x)|}{|x|}}&={\frac {|d_{0}.d_{1}d_{2}\ldots d_{p-1}d_{p}d_{p+1}\ldots \times \beta ^{n}-d_{0}.d_{1}d_{2}\ldots d_{p-1}\times \beta ^{n}|}{|d_{0}.d_{1}d_{2}\ldots \times \beta ^{n}|}}\\&={\frac {|d_{p}.d_{p+1}\ldots \times \beta ^{n-p}|}{|d_{0}.d_{1}d_{2}\ldots \times \beta ^{n}|}}\\&={\frac {|d_{p}.d_{p+1}d_{p+2}\ldots |}{|d_{0}.d_{1}d_{2}\ldots |}}\times \beta ^{-p}\end{aligned}}}

• In order to determine the maximum of this quantity, we need to find the maximum of the numerator and the minimum of the denominator. Since ${\displaystyle d_{0}\neq 0}$ (normalized system), the minimum value of the denominator is ${\displaystyle 1}$. The numerator is bounded above by ${\displaystyle (\beta -1).(\beta -1){\overline {(\beta -1)}}=\beta }$. Thus, ${\displaystyle {\frac {|x-fl(x)|}{|x|}}\leq {\frac {\beta }{1}}\times \beta ^{-p}=\beta ^{1-p}}$. Therefore, ${\displaystyle \epsilon =\beta ^{1-p}}$ for round-by-chop.

The proof for round-to-nearest is similar.

• Note that the first definition of machine epsilon is not quite equivalent to the second definition when using the round-to-nearest rule but it is equivalent for round-by-chop.

Roundoff error caused by floating-point arithmetic

Even if some numbers can be represented exactly by floating-point numbers and such numbers are called machine numbers, performing floating-point arithmetic may lead to roundoff error in the final result.

Machine addition consists of lining up the decimal points of the two numbers to be added, adding them, and then storing the result again as a floating-point number. The addition itself can be done in higher precision but the result must be rounded back to the specified precision, which may lead to roundoff error. [3]

For example, adding ${\displaystyle 1}$ to ${\displaystyle 2^{-53}}$ in IEEE double precision as follows,

{\displaystyle {\begin{aligned}1.00\ldots 0\times 2^{0}+1.00\ldots 0\times 2^{-53}&=1.\underbrace {00\ldots 0} _{\text{52 bits}}\times 2^{0}+0.\underbrace {00\ldots 0} _{\text{52 bits}}1\times 2^{0}\\&=1.\underbrace {00\ldots 0} _{\text{52 bits}}1\times 2^{0}\end{aligned}}}

• This is saved as ${\displaystyle 1.\underbrace {00\ldots 0} _{\text{52 bits}}\times 2^{0}}$ since round-to-nearest is used in IEEE standard. Therefore, ${\displaystyle 1+2^{-53}}$ is equal to ${\displaystyle 1}$ in IEEE double precision and the roundoff error is ${\displaystyle 2^{-53}}$.

From this example, we can see that roundoff error can be introduced when doing the addition of a large number and a small number because the shifting of decimal points in the mantissas to make the exponents match may cause the loss of some digits.

Multiplication

In general, the product of ${\displaystyle 2}$ ${\displaystyle p}$-digit mantissas contains up to ${\displaystyle 2p}$ digits, so the result might not fit in the mantissa. [3] Thus roundoff error will be involved in the result.

• For example, consider a normalized floating-point number system with the base ${\displaystyle \beta =10}$ and the mantissa digits are at most ${\displaystyle 2}$. Then ${\displaystyle fl(77)=7.7\times 10}$ and ${\displaystyle fl(88)=8.8\times 10}$. Note that ${\displaystyle 77\times 88=6776}$ but ${\displaystyle fl(6776)=6.7\times 10^{3}}$ since there at most ${\displaystyle 2}$ mantissa digits. The roundoff error would be ${\displaystyle 6776-fl(6776)=6776-6.7\times 10^{3}=76}$.

Division

In general, the quotient of ${\displaystyle 2}$ ${\displaystyle p}$-digit mantissas may contain more than ${\displaystyle p}$-digits. [3] Thus roundoff error will be involved in the result.

• For example, if we still use the normalized floating-point number system above, then ${\displaystyle 1/3=0.333\ldots }$ but ${\displaystyle fl(1/3)=fl(0.333\ldots )=3.3\times 10^{-1}}$. So, the tail ${\displaystyle 0.333\ldots -3.3\times 10^{-1}=0.00333\ldots }$ is cut off.

Subtractive Cancellation

The subtracting of two nearly equal numbers is called subtractive cancellation. [3]

• When the leading digits are cancelled, the result may be too small to be represented exactly and it will just be represented as ${\displaystyle 0}$.
• For example, let ${\displaystyle |\epsilon |<\epsilon _{mach}}$ and the second definition of machine epsilon is used here. What is the solution to ${\displaystyle (1+\epsilon )-(1-\epsilon )}$?
We know that ${\displaystyle 1+\epsilon }$ and ${\displaystyle 1-\epsilon }$ are nearly equal numbers, and ${\displaystyle (1+\epsilon )-(1-\epsilon )=1+\epsilon -1+\epsilon =2\epsilon }$. However, in the floating-point number system, ${\displaystyle fl((1+\epsilon )-(1-\epsilon ))=fl(1+\epsilon )-fl(1-\epsilon )=1-1=0}$. We can see that ${\displaystyle 2\epsilon }$ is too small so it is represented as ${\displaystyle 0}$.
• Even if the result is representable, the result is still regarded as "garbage". We do not have much faith in this value because the most uncertainty in any floating-point number is the digits on the far right.
• For example, ${\displaystyle 1.99999\times 10^{2}-1.99998\times 10^{2}=0.00001\times 10^{2}=1\times 10^{-5}\times 10^{2}=1\times 10^{-3}}$. The result ${\displaystyle 1\times 10^{-3}}$ is clearly representable, but we do not have much faith in it.

Accumulation of roundoff error

Errors can be magnified or accumulated when a sequence of calculations is applied on an initial input with roundoff error due to inexact representation.

Unstable algorithms

An algorithm or numerical process is called stable if small changes in the input only produce small changes in the output and it is called unstable if large changes in the output are produced. [11]

A sequence of calculations normally occur when running some algorithm. The amount of error in the result depends on the stability of the algorithm. Roundoff error will be magnified by unstable algorithms.

For example, ${\displaystyle y_{n}=\int _{0}^{1}\,{\frac {x^{n}}{x+5}}dx}$ for ${\displaystyle n=1,2,\ldots ,8}$ with ${\displaystyle y_{0}}$ given. It is easy to show that ${\displaystyle y_{n}={\frac {1}{n}}-5y_{n-1}}$. Suppose ${\displaystyle y_{0}}$ is our initial value and has a small representation error ${\displaystyle \epsilon }$, which means the initial input to this algorithm is ${\displaystyle y_{0}+\epsilon }$ instead of ${\displaystyle y_{0}}$. Then the algorithm does the following sequence of calculations.

{\displaystyle {\begin{aligned}y_{1}&=1-5(y_{0}+\epsilon )=1-5y_{0}-5\epsilon \\y_{2}&={\frac {1}{2}}-5(1-5y_{0}-5\epsilon )={\frac {1}{2}}-5+25y_{0}+5^{2}\epsilon \\\vdots \\y_{n}&=\ldots +5^{n}\epsilon \end{aligned}}}

The roundoff error is amplified in succeeding calculations so this algorithm is unstable.

Ill-conditioned problems

Comparison1
Comparison 2

Even if a stable algorithm is used, the solution to a problem is still inaccurate due to the accumulation of roundoff error when the problem itself is ill-conditioned.

The condition number of a problem is the ratio of the relative change in the solution to the relative change in the input. [3] A problem is well-conditioned if small relative changes in input result in small relative changes in the solution. Otherwise. the problem is called ill-conditioned. [3] In other words, a problem is called ill-conditioned if its condition number is "much larger" than ${\displaystyle 1}$.

The condition number is introduced as a measure of the roundoff errors that can result when solving ill-conditioned problems. [7]

For example, higher-order polynomials tend to be very ill-conditioned, that is, they tend to be highly sensitive to roundoff error. [7]

In 1901, Carl Runge published a study on the dangers of higher-order polynomial interpolation. He looked at the following simple-looking function:

${\displaystyle f(x)={\frac {1}{1+25x^{2}}}}$

which is now called Runge's function. He took equidistantly spaced data points from this function over the interval ${\displaystyle [-1,1]}$. He then used interpolating polynomials of increasing order and found that as he took more points, the polynomials and the original curve differed considerably as illustrated in Figure “Comparison1” and Figure “Comparison 2”. Further, the situation deteriorated greatly as the order was increased. As shown in Figure “Comparison 2”, the fit has gotten even worse, particularly at the ends of the interval.

Click on the figures in order to see the full descriptions.

Real world example: Patriot Missile Failure due to magnification of roundoff error

American Patriot Missile

On February 25, 1991, during the Gulf War, an American Patriot Missile battery in Dharan, Saudi Arabia, failed to intercept an incoming Iraqi Scud missile. The Scud struck an American Army barracks and killed 28 soldiers. A report of the General Accounting office, GAO/IMTEC-92-26, entitled Patriot Missile Defense: Software Problem Led to System Failure at Dhahran, Saudi Arabia reported on the cause of the failure. It turns out that the cause was an inaccurate calculation of the time since boot due to computer arithmetic errors. Specifically, the time in tenths of second as measured by the system's internal clock was multiplied by 1/10 to produce the time in seconds. This calculation was performed using a 24-bit fixed point register. In particular, the value 1/10, which has a non-terminating binary expansion, was chopped at 24 bits after the radix point. The small chopping error, when multiplied by the large number giving the time in tenths of a second, lead to a significant error. Indeed, the Patriot battery had been up around 100 hours, and an easy calculation shows that the resulting time error due to the magnified chopping error was about 0.34 seconds. (The number 1/10 equals ${\displaystyle 1/2^{4}+1/2^{5}+1/2^{8}+1/2^{9}+1/2^{12}+1/2^{13}+\ldots }$. In other words, the binary expansion of 1/10 is ${\displaystyle 0.0001100110011001100110011001100\ldots }$. Now the 24 bit register in the Patriot stored instead ${\displaystyle 0.00011001100110011001100}$ introducing an error of ${\displaystyle 0.0000000000000000000000011001100\ldots }$ binary, or about ${\displaystyle 0.000000095}$ decimal. Multiplying by the number of tenths of a second in ${\displaystyle 100}$ hours gives ${\displaystyle 0.000000095\times 100\times 60\times 60\times 10=0.34}$). A Scud travels at about 1,676 meters per second, and so travels more than half a kilometer in this time. This was far enough that the incoming Scud was outside the "range gate" that the Patriot tracked. Ironically, the fact that the bad time calculation had been improved in some parts of the code, but not all, contributed to the problem, since it meant that the inaccuracies did not cancel.[12]

References

1. ^ Butt, Rizwan (2009), Introduction to Numerical Analysis Using MATLAB, Jones & Bartlett Learning, pp. 11–18, ISBN 9780763773762.
2. ^ Ueberhuber, Christoph W. (1997), Numerical Computation 1: Methods, Software, and Analysis, Springer, pp. 139–146, ISBN 9783540620587.
3. Forrester, Dick (2018). Math/Comp241 Numerical Methods (lecture notes). Dickinson College..
4. ^ Aksoy, Pelin; DeNardis, Laura (2007), Information Technology in Theory, Cengage Learning, p. 134, ISBN 9781423901402.
5. ^ Ralston, Anthony; Rabinowitz, Philip (2012), A First Course in Numerical Analysis, Dover Books on Mathematics (2nd ed.), Courier Dover Publications, pp. 2–4, ISBN 9780486140292.
6. ^ Chapman, Stephen (2012), MATLAB Programming with Applications for Engineers, Cengage Learning, p. 454, ISBN 9781285402796.
7. ^ a b c Chapra, Steven (2012). Applied Numerical Methods with MATLAB for Engineers and Scientists (3rd ed.). The McGraw-Hill Companies, Inc. ISBN 9780073401102.
8. ^ Laplante, Philip A. (2000). Dictionary of Computer Science, Engineering and Technology. CRC Press. p. 420. ISBN 9780849326912..
9. ^ Higham, Nicholas John (2002). Accuracy and Stability of Numerical Algorithms (2 ed.). Society for Industrial and Applied Mathematics (SIAM). pp. 43–44. ISBN 9780898715217..
10. ^ Volkov, E. A. (1990). Numerical Methods. Taylor & Francis. p. 24. ISBN 9781560320111..
11. ^ Collins, Charles (2005). "Condition and Stability" (PDF). Department of Mathematics in University of Tennessee. Retrieved 28 October 2018.
12. ^ Arnold, Douglas. "The Patriot Missile Failure". Retrieved 29 October 2018.
Basis of this page is in Wikipedia. Text is available under the CC BY-SA 3.0 Unported License. Non-text media are available under their specified licenses. Wikipedia® is a registered trademark of the Wikimedia Foundation, Inc. WIKI 2 is an independent company and has no affiliation with Wikimedia Foundation.