Bearing capacity: Difference between revisions

From formulasearchengine
Jump to navigation Jump to search
en>Nick Levine
m Reverted edits by 60.254.116.34 (talk) to last version by DMacks
en>Hamlehdari
Line 1: Line 1:
In [[numerical analysis]], one or more '''guard digits''' can be used to reduce the amount of [[Rounding|roundoff]] error.
Alyson is what my spouse loves to contact me but I don't like when individuals use my full title. Distributing production is exactly where her main income arrives from. I am really fond of handwriting but I can't make it my profession truly. My spouse and I reside in Mississippi but now I'm contemplating other choices.<br><br>My blog post; [http://cspl.postech.ac.kr/zboard/Membersonly/144571 cheap psychic readings]
 
For example, suppose that the final result of a long, multi-step calculation can be safely rounded off to ''N'' decimal places. That is to say, the roundoff error introduced by this final roundoff makes a negligible contribution to the overall uncertainty.
 
However, it is quite likely that it is ''not'' safe to round off the intermediate steps in the calculation to the same number of digits.  Be aware that roundoff errors can accumulate. If ''M'' decimal places are used in the intermediate calculation, we say there are ''M−N'' guard digits.
 
Guard digits are also used in floating point operations in most computer systems. Given <math>2^1 \times 0.100_2 - 2^0 \times 0.111_2</math> we have to line up the binary points.  This means we must add an extra digit to the first operand—a guard digit.  This gives us <math>2^1 \times 0.1000_2 - 2^1 \times 0.0111_2</math>.  Performing this operation gives us <math>2^1 \times 0.0001_2</math> or <math>2^{-2} \times 0.100_2</math>. Without using a guard digit we have <math>2^1 \times 0.100_2 - 2^1 \times 0.011_2</math>, yielding <math>2^1 \times 0.001_2=</math> or <math>2^{-1} \times 0.100_2</math>.  This gives us a relative error of 1.  Therefore we can see how important guard digits can be.
 
An example of the error caused by floating point roundoff is illustrated in the following [[C (programming language)|C]] code.
 
<source lang="c">
int main(){
  float a;
  int i;
  a = 0.2; a += 0.1; a -= 0.3;
  for(i=0 ; a<1.0 ; i++) a += a;
  printf(" i=%d a=%f\n",i,a);
  return 0;
}
</source>
It appears that the program should not terminate. Yet the output is :  i=27 a=1.600000
 
Another example is:
 
Take 2 numbers: <br>
2.56*10^0 and <br>
2.34*10^2 <br>
we bring the first number to the same power of 10 as the second one: <br>
0.0256*10^2 
 
The addition of the 2 numbers is:<br>
0.0256*10^2 + <br>
2.3400*10^2  <br>
____________ <br>
2.3656*10^2  <br>
After padding the second number with 0, the bit after 4 is the guard digit and the bit after is the round digit. The result after rounding is 2.37 as opposed to 2.36 without the extra bits (guard and round bits), i.e. by considering only 0.02+2.34 = 2.36. The error therefore is 0.01.
 
==References==
* [[Forman S. Acton]].  ''Numerical Methods that Work'', The Mathematical Association of America (August 1997).
* Higham, Nicholas J. ''Accuracy and Stability of Numerical Algorithms'', Washington D.C.: Society for Industrial & Applied Mathematics, 2002.
 
[[Category:Numerical analysis]]
 
 
{{mathanalysis-stub}}

Revision as of 22:24, 3 March 2014

Alyson is what my spouse loves to contact me but I don't like when individuals use my full title. Distributing production is exactly where her main income arrives from. I am really fond of handwriting but I can't make it my profession truly. My spouse and I reside in Mississippi but now I'm contemplating other choices.

My blog post; cheap psychic readings