Representation of Numbers in the Computer - Revision history

Davrot: /* Rounding Error */

2025-10-20T10:29:28Z

Rounding Error

← Older revision		Revision as of 10:29, 20 October 2025
Line 195:		Line 195:

	x = x * 2		x = x * 2
	print(x) # -> 2.220446049250313e-16</syntaxhighlight>One might think that this constitutes an infinite loop. To the contrary, the loop will be left in finite time. The result for double precision is <math display="inline">x \approx 2\times 10^{-16}</math><syntaxhighlight lang="python3">		print(x) # -> 2.220446049250313e-16</syntaxhighlight>One might think that this constitutes an infinite loop. To the contrary, the loop will be left in finite time. The result for double precision is <math display="inline">x \approx 2\times 10^{-16}</math> <syntaxhighlight lang="python3">
	import sys		import sys
	print(sys.float_info.epsilon)		print(sys.float_info.epsilon)
	</syntaxhighlight>eps is the smallest number with <math display="inline">1+\epsilon > 1</math>		</syntaxhighlight>eps is the smallest number with <math display="inline">1+\epsilon > 1</math>

	, and is the . Rounding errors of this order of magnitude occur on a regular basis. For example, Python calculates <math display="inline">\sin{\pi} \approx 1.2246\times 10^{-16}</math> <syntaxhighlight lang="python3">		, and is the . Rounding errors of this order of magnitude occur on a regular basis. For example, Python calculates <math display="inline">\sin{\pi} \approx 1.2246\times 10^{-16}</math> <syntaxhighlight lang="python3">

Davrot: /* Rounding Error */

2025-10-20T10:28:54Z

Rounding Error

← Older revision		Revision as of 10:28, 20 October 2025
Line 195:		Line 195:

	x = x * 2		x = x * 2
	print(x) # -> 2.220446049250313e-16</syntaxhighlight>One might think that this constitutes an infinite loop. To the contrary, the loop will be left in finite time. The result for double precision is<math display="inline">x \approx 2\times 10^{-16}</math> <syntaxhighlight lang="python3">		print(x) # -> 2.220446049250313e-16</syntaxhighlight>One might think that this constitutes an infinite loop. To the contrary, the loop will be left in finite time. The result for double precision is <math display="inline">x \approx 2\times 10^{-16}</math><syntaxhighlight lang="python3">
	import sys		import sys
	print(sys.float_info.epsilon)		print(sys.float_info.epsilon)
	</syntaxhighlight>eps is the smallest number with <math display="inline">1+\epsilon > 1</math>, and is the . Rounding errors of this order of magnitude occur on a regular basis. For example, Python calculates <math display="inline">\sin{\pi} \approx 1.2246\times 10^{-16}</math> <syntaxhighlight lang="python3">		</syntaxhighlight>eps is the smallest number with <math display="inline">1+\epsilon > 1</math>

			, and is the . Rounding errors of this order of magnitude occur on a regular basis. For example, Python calculates <math display="inline">\sin{\pi} \approx 1.2246\times 10^{-16}</math> <syntaxhighlight lang="python3">
	import math		import math
	print(math.sin(math.pi))		print(math.sin(math.pi))
	</syntaxhighlight>It shall be mentioned hat the machine accuracy for double precision is exactly ~~eps~~ <math display="inline">= 2^{-52}</math>, since 52 bits (plus one bit for the sign) are used for the mantissa. This rounding error might appear to be small and negligible. However, if further calculations are performed with rounded numbers, the rounding errors can accumulate with each calculation and grow to a significant value.		</syntaxhighlight>It shall be mentioned hat the machine accuracy for double precision is exactly <math display="inline">\epsilon= 2^{-52}</math>, since 52 bits (plus one bit for the sign) are used for the mantissa. This rounding error might appear to be small and negligible. However, if further calculations are performed with rounded numbers, the rounding errors can accumulate with each calculation and grow to a significant value.

Davrot: /* Rounding Error */

2025-10-20T10:28:09Z

Rounding Error

← Older revision		Revision as of 10:28, 20 October 2025
Line 195:		Line 195:

	x = x * 2		x = x * 2
	print(x) # -> 2.220446049250313e-16</syntaxhighlight>One might think that this constitutes an infinite loop. To the contrary, the loop will be left in finite time. The result for double precision is <math display="inline">x \approx 2\times 10^{-16}</math>(import sys ; print(sys.float_info.epsilon) ). eps is the smallest number with <math display="inline">1+\epsilon > 1</math> , and is the . Rounding errors of this order of magnitude occur on a regular basis. For example, Python calculates		print(x) # -> 2.220446049250313e-16</syntaxhighlight>One might think that this constitutes an infinite loop. To the contrary, the loop will be left in finite time. The result for double precision is<math display="inline">x \approx 2\times 10^{-16}</math> <syntaxhighlight lang="python3">
	<math display="inline">\sin{\pi} \approx 1.2246\times 10^{-16}</math>		import sys
			print(sys.float_info.epsilon)
	(import math ; print(math.sin(math.pi)) ). It shall be mentioned hat the machine accuracy for double precision is exactly eps <math display="inline">= 2^{-52}</math>, since 52 bits (plus one bit for the sign) are used for the mantissa. This rounding error might appear to be small and negligible. However, if further calculations are performed with rounded numbers, the rounding errors can accumulate with each calculation and grow to a significant value.		</syntaxhighlight>eps is the smallest number with <math display="inline">1+\epsilon > 1</math>, and is the . Rounding errors of this order of magnitude occur on a regular basis. For example, Python calculates <math display="inline">\sin{\pi} \approx 1.2246\times 10^{-16}</math> <syntaxhighlight lang="python3">
			import math
			print(math.sin(math.pi))
			</syntaxhighlight>It shall be mentioned hat the machine accuracy for double precision is exactly eps <math display="inline">= 2^{-52}</math>, since 52 bits (plus one bit for the sign) are used for the mantissa. This rounding error might appear to be small and negligible. However, if further calculations are performed with rounded numbers, the rounding errors can accumulate with each calculation and grow to a significant value.

Davrot: /* Representation of Real Numbers and Numerical Errors */

2025-10-20T10:25:37Z

Representation of Real Numbers and Numerical Errors

← Older revision		Revision as of 10:25, 20 October 2025
Line 147:		Line 147:
	floating-point number = mantissa ⋅ basis <sup>exponent</sup>		floating-point number = mantissa ⋅ basis <sup>exponent</sup>

	Thereby, the precision, with which the real number can be represented, is determined by the number of available bits.”Simple precision” (i.e. float32) requires 4 Bytes, for ''double precision'' (i.e. float64) 8~Bytes are needed. The latter is the default configuration in Python and Matlab. The IEEE format of double precision uses 53-Bits for the mantissa, 11-Bits for the exponent and for the basis the remaining 2. One Bit of the mantissa respectively the exponent are used for the sign of the quantity. Thus, the exponent can vary between<math display="inline">-1024</math> and <math display="inline">+1023</math>. The mantissa always represents a value in the interval <math display="inline">[1, 2[</math> in the IEEE notation. Here, the <math display="inline">52</math> Bits are utilized to add up fractions of exponents of 2. The value of the mantissa yields <math display="~~block~~">mantissa = 1 + \sum_{i=1}^{52} b_i 2^{-i}</math>, with <math display="inline">b_i=1</math> , if the <math display="inline">i</math>-th bit in the mantissa is set.		Thereby, the precision, with which the real number can be represented, is determined by the number of available bits.”Simple precision” (i.e. float32) requires 4 Bytes, for ''double precision'' (i.e. float64) 8~Bytes are needed. The latter is the default configuration in Python and Matlab. The IEEE format of double precision uses 53-Bits for the mantissa, 11-Bits for the exponent and for the basis the remaining 2. One Bit of the mantissa respectively the exponent are used for the sign of the quantity. Thus, the exponent can vary between<math display="inline">-1024</math> and <math display="inline">+1023</math>. The mantissa always represents a value in the interval <math display="inline">[1, 2[</math> in the IEEE notation. Here, the <math display="inline">52</math> Bits are utilized to add up fractions of exponents of 2. The value of the mantissa yields <math display="inline">mantissa = 1 + \sum_{i=1}^{52} b_i 2^{-i}</math>, with <math display="inline">b_i=1</math> , if the <math display="inline">i</math>-th bit in the mantissa is set.

	== Range Error ==		== Range Error ==

Davrot: /* Rounding Error */

2025-10-14T14:21:36Z

Rounding Error

← Older revision		Revision as of 14:21, 14 October 2025
Line 195:		Line 195:

	x = x * 2		x = x * 2
	print(x) # -> 2.220446049250313e-16</syntaxhighlight>One might think that this constitutes an infinite loop. To the contrary, the loop will be left in finite time. The result for double precision is <math display="inline">x \approx 2\times 10^{-16}</math>(import sys ; print(sys.float_info.epsilon) ). eps is the smallest number with <math display="inline">1+~~</math>eps<math display="inline">~~>1</math>, and is the . Rounding errors of this order of magnitude occur on a regular basis. For example, Python calculates <math display="inline">\sin{\pi} \approx 1.2246\times 10^{-16}</math>(import math ; print(math.sin(math.pi)) ). It shall be mentioned hat the machine accuracy for double precision is exactly eps <math display="inline">= 2^{-52}</math>, since 52 bits (plus one bit for the sign) are used for the mantissa. This rounding error might appear to be small and negligible. However, if further calculations are performed with rounded numbers, the rounding errors can accumulate with each calculation and grow to a significant value.		print(x) # -> 2.220446049250313e-16</syntaxhighlight>One might think that this constitutes an infinite loop. To the contrary, the loop will be left in finite time. The result for double precision is <math display="inline">x \approx 2\times 10^{-16}</math>(import sys ; print(sys.float_info.epsilon) ). eps is the smallest number with <math display="inline">1+\epsilon > 1</math> , and is the . Rounding errors of this order of magnitude occur on a regular basis. For example, Python calculates
			<math display="inline">\sin{\pi} \approx 1.2246\times 10^{-16}</math>

			(import math ; print(math.sin(math.pi)) ). It shall be mentioned hat the machine accuracy for double precision is exactly eps <math display="inline">= 2^{-52}</math>, since 52 bits (plus one bit for the sign) are used for the mantissa. This rounding error might appear to be small and negligible. However, if further calculations are performed with rounded numbers, the rounding errors can accumulate with each calculation and grow to a significant value.

Davrot: /* Rounding Error */

2025-10-14T14:20:40Z

Rounding Error

← Older revision		Revision as of 14:20, 14 October 2025
Line 195:		Line 195:

	x = x * 2		x = x * 2
	print(x) # -> 2.220446049250313e-16</syntaxhighlight>One might think that this constitutes an infinite loop. To the contrary, the loop will be left in finite time. The result for double precision is <math display="inline">x \approx 2\times 10^{-16}</math> (import sys ; print(sys.float_info.epsilon) ). eps is the smallest number with <math display="inline">1+</math>eps<math display="inline">>1</math>, and is the . Rounding errors of this order of magnitude occur on a regular basis. For example, Python calculates<math display="inline">\sin{\pi} \approx 1.2246\times 10^{-16}</math>(import math ; print(math.sin(math.pi)) ). It shall be mentioned hat the machine accuracy for double precision is exactly eps<math display="inline">= 2^{-52}</math>, since 52 bits (plus one bit for the sign) are used for the mantissa. This rounding error might appear to be small and negligible. However, if further calculations are performed with rounded numbers, the rounding errors can accumulate with each calculation and grow to a significant value.		print(x) # -> 2.220446049250313e-16</syntaxhighlight>One might think that this constitutes an infinite loop. To the contrary, the loop will be left in finite time. The result for double precision is <math display="inline">x \approx 2\times 10^{-16}</math>(import sys ; print(sys.float_info.epsilon) ). eps is the smallest number with <math display="inline">1+</math>eps<math display="inline">>1</math>, and is the . Rounding errors of this order of magnitude occur on a regular basis. For example, Python calculates <math display="inline">\sin{\pi} \approx 1.2246\times 10^{-16}</math>(import math ; print(math.sin(math.pi)) ). It shall be mentioned hat the machine accuracy for double precision is exactly eps <math display="inline">= 2^{-52}</math>, since 52 bits (plus one bit for the sign) are used for the mantissa. This rounding error might appear to be small and negligible. However, if further calculations are performed with rounded numbers, the rounding errors can accumulate with each calculation and grow to a significant value.

Davrot: /* Range Error */

2025-10-14T14:19:50Z

Range Error

← Older revision		Revision as of 14:19, 14 October 2025
Line 174:		Line 174:
	For bigger <math display="inline">n</math>, the evaluation of this expression is, however, to laborious. If <math display="inline">n>30</math>, one is advised to use Stirling’s formula		For bigger <math display="inline">n</math>, the evaluation of this expression is, however, to laborious. If <math display="inline">n>30</math>, one is advised to use Stirling’s formula

	<math>\ln(n!) = \ln(n) + \ln(n-1) + \~~ldots~~ + \~~ln(3)~~ + \~~ln(~~2) + \~~ln(1~~) </math>		<math>\ln(n!) = n\ln(n)-n+\frac{1}{2}\ln(2\pi n)+\ln\left(1+\frac{1}{12n}+\frac{1}{288n^2}+\ldots\right)</math>

	The factorial <math display="inline">n!</math> can than be written as the following		The factorial <math display="inline">n!</math> can than be written as the following

Davrot: /* Range Error */

2025-10-14T14:18:22Z

Range Error

← Older revision		Revision as of 14:18, 14 October 2025
Line 170:		Line 170:
	In Python or Matlab, it can be easily verified by using the function factorial(n), that the factorial for <math display="inline">n>170</math> can not be represented, even with double precision numbers. A way out is provided by the use of logarithms, since the logarithm of a bigger number still gives moderately small values, e.g. <math display="inline">\log_{10}(10^{100}) = 100</math>. It ensues that		In Python or Matlab, it can be easily verified by using the function factorial(n), that the factorial for <math display="inline">n>170</math> can not be represented, even with double precision numbers. A way out is provided by the use of logarithms, since the logarithm of a bigger number still gives moderately small values, e.g. <math display="inline">\log_{10}(10^{100}) = 100</math>. It ensues that

	$(n!) = (n) + (n-1) + + (3) + (2) + (1) $		<math>\ln(n!) = \ln(n) + \ln(n-1) + \ldots + \ln(3) + \ln(2) + \ln(1)</math>

	For bigger <math display="inline">n</math>, the evaluation of this expression is, however, to laborious. If <math display="inline">n>30</math>, one is advised to use Stirling’s formula		For bigger <math display="inline">n</math>, the evaluation of this expression is, however, to laborious. If <math display="inline">n>30</math>, one is advised to use Stirling’s formula

Davrot: /* Representation of Real Numbers and Numerical Errors */

2025-10-14T14:17:17Z

Representation of Real Numbers and Numerical Errors

← Older revision		Revision as of 14:17, 14 October 2025
Line 147:		Line 147:
	floating-point number = mantissa ⋅ basis <sup>exponent</sup>		floating-point number = mantissa ⋅ basis <sup>exponent</sup>

	Thereby, the precision, with which the real number can be represented, is determined by the number of available bits.”Simple precision” (i.e. float32) requires 4 Bytes, for ''double precision'' (i.e. float64) 8~Bytes are needed. The latter is the default configuration in Python and Matlab. The IEEE format of double precision uses 53-Bits for the mantissa, 11-Bits for the exponent and for the basis the remaining 2. One Bit of the mantissa respectively the exponent are used for the sign of the quantity. Thus, the exponent can vary between<math display="inline">-1024</math> and <math display="inline">+1023</math>. The mantissa always represents a value in the interval <math display="inline">[1, 2[</math> in the IEEE notation. Here, the <math display="inline">52</math> Bits are utilized to add up fractions of exponents of 2. The value of the mantissa yields <math display="block">mantissa = 1 + \sum_{i=1}^{52} b_i 2^{-i}</math> , with <math display="inline">b_i=1</math> , if the <math display="inline">i</math>-th bit in the mantissa is set.		Thereby, the precision, with which the real number can be represented, is determined by the number of available bits.”Simple precision” (i.e. float32) requires 4 Bytes, for ''double precision'' (i.e. float64) 8~Bytes are needed. The latter is the default configuration in Python and Matlab. The IEEE format of double precision uses 53-Bits for the mantissa, 11-Bits for the exponent and for the basis the remaining 2. One Bit of the mantissa respectively the exponent are used for the sign of the quantity. Thus, the exponent can vary between<math display="inline">-1024</math> and <math display="inline">+1023</math>. The mantissa always represents a value in the interval <math display="inline">[1, 2[</math> in the IEEE notation. Here, the <math display="inline">52</math> Bits are utilized to add up fractions of exponents of 2. The value of the mantissa yields <math display="block">mantissa = 1 + \sum_{i=1}^{52} b_i 2^{-i}</math>, with <math display="inline">b_i=1</math> , if the <math display="inline">i</math>-th bit in the mantissa is set.

	== Range Error ==		== Range Error ==

Davrot at 14:16, 14 October 2025

2025-10-14T14:16:17Z

← Older revision		Revision as of 14:16, 14 October 2025
Line 156:		Line 156:
	and for double precision		and for double precision

	~~<nowiki>~~<math ~~display="inline"></nowiki~~>		<math>2^{\pm 1023} \approx 10^{\pm 308}</math>

	2^{\pm 1023} \approx 10^{\pm 308}

	~~<nowiki>~~</math~~></nowiki~~>

	Via application of arithmetic operations on these numbers, the range can be exceeded. The error occurring in that case is named a range error. As an example we consider the Bohr radius in SI units		Via application of arithmetic operations on these numbers, the range can be exceeded. The error occurring in that case is named a range error. As an example we consider the Bohr radius in SI units

	$a_0 = ^{-11} $		<math>a_0 = \frac{4\pi\varepsilon_0\hbar^2}{m_ee^2}\approx 5.3\times 10^{-11} \mbox{m}</math>

	The quantity <math display="inline">\hbar</math> is Planck’s quantum of action divided by <math display="inline">2\pi</math>. Bohr’s radius is in the range of single precision floating-point numbers. However, the same does not hold for the numerator <math display="inline">4\pi\varepsilon_0\hbar^2 \approx 1.24\cdot 10^{-78}\mbox{KgC}^2\mbox{m}</math> and the denominator <math display="inline">m_ee^2 \approx 2.34\times 10^{-68}\mbox{KgC}^2</math>. I.e. neither the numerator nor the denominator can be represented as a single precision floating-point number. Hence, the calculation of Bohr’s radius by the given formula can be problematic. A simple solution of this problem lies in the use of natural units, such as Bohr’s radius, for distances, etc.		The quantity <math display="inline">\hbar</math> is Planck’s quantum of action divided by <math display="inline">2\pi</math>. Bohr’s radius is in the range of single precision floating-point numbers. However, the same does not hold for the numerator <math display="inline">4\pi\varepsilon_0\hbar^2 \approx 1.24\cdot 10^{-78}\mbox{KgC}^2\mbox{m}</math> and the denominator <math display="inline">m_ee^2 \approx 2.34\times 10^{-68}\mbox{KgC}^2</math>. I.e. neither the numerator nor the denominator can be represented as a single precision floating-point number. Hence, the calculation of Bohr’s radius by the given formula can be problematic. A simple solution of this problem lies in the use of natural units, such as Bohr’s radius, for distances, etc.
Line 170:		Line 166:
	An even bigger problem can be illustrated by the calculation of the factorial. The factorial is defined as		An even bigger problem can be illustrated by the calculation of the factorial. The factorial is defined as

	$n! = n(n-1)(n-2)~~3 $~~		<math>n! = n\cdot(n-1)\cdot(n-2)\cdot\ldots3\cdot 2\cdot 1</math>

	In Python or Matlab, it can be easily verified by using the function factorial(n), that the factorial for <math display="inline">n>170</math> can not be represented, even with double precision numbers. A way out is provided by the use of logarithms, since the logarithm of a bigger number still gives moderately small values, e.g. <math display="inline">\log_{10}(10^{100}) = 100</math>. It ensues that		In Python or Matlab, it can be easily verified by using the function factorial(n), that the factorial for <math display="inline">n>170</math> can not be represented, even with double precision numbers. A way out is provided by the use of logarithms, since the logarithm of a bigger number still gives moderately small values, e.g. <math display="inline">\log_{10}(10^{100}) = 100</math>. It ensues that
Line 178:		Line 174:
	For bigger <math display="inline">n</math>, the evaluation of this expression is, however, to laborious. If <math display="inline">n>30</math>, one is advised to use Stirling’s formula		For bigger <math display="inline">n</math>, the evaluation of this expression is, however, to laborious. If <math display="inline">n>30</math>, one is advised to use Stirling’s formula

	$(n!) = n(n)-n+(2n)+(1~~+++~~) $		<math>\ln(n!) = \ln(n) + \ln(n-1) + \ldots + \ln(3) + \ln(2) + \ln(1) </math>

	The factorial <math display="inline">n!</math> can than be written as the following		The factorial <math display="inline">n!</math> can than be written as the following

	$n! = ^{} $		<math>n! = \mbox{mantissa}\times 10^{\mbox{exponent}}</math>

	To get the mantissa and the exponent, we form the logarithm to the basis 10 (reminder: <math display="inline">\log_{10}(x) = \ln(x)/\ln(10)</math>)		To get the mantissa and the exponent, we form the logarithm to the basis 10 (reminder: <math display="inline">\log_{10}(x) = \ln(x)/\ln(10)</math>)

	~~$''~~{10}(n!) ='' {10}()+{} $		<math>\log_{10}(n!) = \log_{10}(\mbox{mantissa})+{\mbox{exponent}}</math>

	We now associate the integer part of <math display="inline">\log_{10}(n!)</math> with the exponent. The post-decimal places are associated with the mantissa, i.e. mantissa = <math display="inline">10^a</math> with <math display="inline">a = \log_{10}(n!)-\mbox{exponent}</math>.		We now associate the integer part of <math display="inline">\log_{10}(n!)</math> with the exponent. The post-decimal places are associated with the mantissa, i.e. mantissa = <math display="inline">10^a</math> with <math display="inline">a = \log_{10}(n!)-\mbox{exponent}</math>.
Line 199:		Line 195:

	x = x * 2		x = x * 2
	print(x) # -> 2.220446049250313e-16</syntaxhighlight>One might think that this constitutes an infinite loop. To the contrary, the loop will be left in finite time. The result for double precision is <math display="inline">x \approx 2\times 10^{-16}</math> (import sys ; print(sys.float_info.epsilon) ). eps is the smallest number with <math display="inline">1+</math>eps<math display="inline">>1</math>, and is the . Rounding errors of this order of magnitude occur on a regular basis. For example, Python calculates <math display="inline">\sin{\pi} \approx 1.2246\times 10^{-16}</math> (import math ; print(math.sin(math.pi)) ). It shall be mentioned hat the machine accuracy for double precision is exactly eps <math display="inline">= 2^{-52}</math>, since 52 bits (plus one bit for the sign) are used for the mantissa. This rounding error might appear to be small and negligible. However, if further calculations are performed with rounded numbers, the rounding errors can accumulate with each calculation and grow to a significant value.		print(x) # -> 2.220446049250313e-16</syntaxhighlight>One might think that this constitutes an infinite loop. To the contrary, the loop will be left in finite time. The result for double precision is <math display="inline">x \approx 2\times 10^{-16}</math> (import sys ; print(sys.float_info.epsilon) ). eps is the smallest number with <math display="inline">1+</math>eps<math display="inline">>1</math>, and is the . Rounding errors of this order of magnitude occur on a regular basis. For example, Python calculates<math display="inline">\sin{\pi} \approx 1.2246\times 10^{-16}</math>(import math ; print(math.sin(math.pi)) ). It shall be mentioned hat the machine accuracy for double precision is exactly eps<math display="inline">= 2^{-52}</math>, since 52 bits (plus one bit for the sign) are used for the mantissa. This rounding error might appear to be small and negligible. However, if further calculations are performed with rounded numbers, the rounding errors can accumulate with each calculation and grow to a significant value.