more screenshots replaced with listings

Author: thomasWeise

text/main/basics/simpleDataTypesAndOperations/bool/bool.tex

@@ -48,7 +48,7 @@
 
 When talking about comparisons, there is one important, counter-intuitive exception to recall:
 The \pythonilIdx{nan}\pythonIdx{Not a Number} floating point value\pythonIdx{float} from \cref{sec:float:special}.
-In \cref{fig:floatMathInConsoleNaN}, we learned that \pythonil{nan == nan}\pythonIdx{==} is \pythonilIdx{False} and \pythonil{nan != nan}\pythonIdx{"!=} is \pythonilIdx{True}.
+In \cref{exec:float_nan}, we learned that \pythonil{nan == nan}\pythonIdx{==} is \pythonilIdx{False} and \pythonil{nan != nan}\pythonIdx{"!=} is \pythonilIdx{True}.
 This is the only primitive value (to my knowledge) which is not equal to itself.%
 \endhsection%
 %

text/main/basics/simpleDataTypesAndOperations/float/float.tex

@@ -73,11 +73,11 @@
 \hsection{Floating Point Arithmetic}%
 \label{sec:floatarith}%
 %
-\gitEvalPython{float_arith}{}{simple_datatypes/float_arith.py}%
-\listingBox{exec:float_arith}{Basic arithmetics with floating point numbers in \python.}{,style=python_console_style}%
+\gitEvalPython{float_arithmetics}{}{simple_datatypes/float_arithmetics.py}%
+\listingBox{exec:float_arithmetics}{Basic arithmetics with floating point numbers in \python.}{,style=python_console_style}%
 %
 Floating point numbers in \python\ can be distinguished from \pythonils{int}\pythonIdx{int} by having a decimal dot in their text representation, i.e., \pythonil{5.0} is a \pythonilIdx{float} and \pythonil{5} is an \pythonilIdx{int}.
-Let us now look at some examples for the basic arithmetic operations available for \pythonils{float}\pythonIdx{float} in \cref{exec:float_arith}.
+Let us now look at some examples for the basic arithmetic operations available for \pythonils{float}\pythonIdx{float} in \cref{exec:float_arithmetics}.
 
 We already learned that the division operator~\pythonilIdx{/} always yields a \pythonilIdx{float} result.
 Therefore \pythonil{6 / 3} yields \pythonil{2.0} instead of \pythonil{2}.
@@ -162,12 +162,8 @@
 %
 \hsection{Back to Integers: Rounding}%
 %
-\begin{figure}%
-\centering%
-\includegraphics[width=0.8\linewidth]{\currentDir/floatMathInConsoleRound}%
-\caption{Rounding \pythonilIdx{float} values to \pythonilIdx{int} values.}%
-\label{fig:floatMathInConsoleRound}%
-\end{figure}%
+\gitEvalPython{float_rounding}{}{simple_datatypes/float_rounding.py}%
+\listingBox{exec:float_rounding}{Rounding \pythonilIdx{float} values to \pythonilIdx{int} values.}{,style=python_console_style}%
 %
 We already learned that a single \pythonilIdx{float} value inside a computation that otherwise uses \pythonils{int}\pythonIdx{int} basically forces the whole result to become a \pythonilIdx{float} as well.
 But maybe sometimes we want to have an \pythonilIdx{int} as result.
@@ -179,7 +175,7 @@
 If two integer numbers are equally close, it rounds it to the one that is even.
 This can be very surprising, as we learned in school that $x.5$ should be rounded to $x+1$.
 This will only happen with \pythonilIdx{round} if $x+1$~is even.
-We find examples for the behavior of \pythonilIdx{round} in \cref{fig:floatMathInConsoleRound}.
+We find examples for the behavior of \pythonilIdx{round} in \cref{exec:float_rounding}.
 \pythonil{round(0.4)} yields the integer~\pythonil{0}, as expected.
 \pythonil{round(0.5)} returns~\pythonil{0} as well, which one may not expect -- but \pythonil{0} is even and \pythonil{1} would be odd.
 \pythonil{round(0.6)} gives us the integer~\pythonil{1}.
@@ -233,13 +229,8 @@
 \label{fig:scientificNotation}%
 \end{figure}%
 %
-\begin{figure}%
-\centering%
-%
-\includegraphics[width=0.8\linewidth]{\currentDir/floatMathInConsoleSciNot}%
-\caption{Examples for the scientific notation in \python.}%
-\label{fig:floatMathInConsoleSciNot}%
-\end{figure}%
+\gitEvalPython{float_scientific_notation}{}{simple_datatypes/float_scientific_notation.py}%
+\listingBox{exec:float_scientific_notation}{Examples of the scientific notation in \python.}{,style=python_console_style}%
 %
 Earlier on, we wrote that \pythonils{float}\pythonIdx{float} can represent numbers as large as~$10^{300}$ or as small as~$10^{-300}$.
 This leads to the question how it would print such values on the console and how we can read them.
@@ -256,7 +247,7 @@
 This notation is illustrated in \cref{fig:scientificNotation}.
 \emph{This notation only applies to \pythonils{float}\pythonIdx{float}, \textbf{not} \pythonils{int}\pythonIdx{int}.}
 
-In \cref{fig:floatMathInConsoleSciNot} we provide some examples for this notation.
+In \cref{exec:float_scientific_notation} we provide some examples for this notation.
 When we write \pythonil{0.001} or \pythonil{0.0001} in a \python\ console, the output is still this same number.
 However, \pythonil{0.00009} is presented as \pythonil{9e-05}, which stands for~$9*10^{-5}$.%
 %
@@ -301,12 +292,9 @@
 \hsection{Limits and Special Floating Point Values: Infinity and \inQuotes{Not a Number}}%
 \label{sec:float:special}%
 %
-\begin{figure}%
-\centering%
-\includegraphics[width=0.7\linewidth]{\currentDir/floatMathInConsoleZero}%
-\caption{What happens with very small floating point numbers in \python?\pythonIdx{0.0}}%
-\label{fig:floatMathInConsoleZero}%
-\end{figure}%
+%
+\gitEvalPython{float_very_small}{}{simple_datatypes/float_very_small.py}%
+\listingBox{exec:float_very_small}{What happens with very small floating point numbers in \python?\pythonIdx{0.0}.}{,style=python_console_style}%
 %
 We already learned that the floating point type \pythonilIdx{float} can represent both very small and very large numbers.
 But we also know that it is internally stored as chunk of 64~bits.
@@ -321,7 +309,7 @@
 In its documentation~\cite{O2024JPSEJDKV2AS:CD}, we find that the minimum value is~$2^{-1074}$, which is approximately~$4.940\decSep656\decSep458\decSep412\decSep465\decSep44*10^{-324}$.
 So we would expect the smallest possible floating point value in \python\ to also be in this range.
 
-In \cref{fig:floatMathInConsoleInf}, we take a look what happens if we approach this number.
+In \cref{exec:float_very_large}, we take a look what happens if we approach this number.
 We use the scientific notation and begin to print the number~\pythonil{1e-323} (which is~$10^{-323}$).
 This number is correctly represented as \pythonilIdx{float} and shows up in the console exactly as we wrote it.
 However, if we go a bit smaller and enter \pythonil{9e-324}, which is~$9*10^{-324}=0.9*10^{-323}$, we find that it again shows up in the console as \pythonil{1e-323}.
@@ -343,16 +331,12 @@
 So we learned what happens if we try to define very small floating point numbers:
 They become zero.
 
-\begin{figure}%
-\centering%
-\includegraphics[width=0.7\linewidth]{\currentDir/floatMathInConsoleInf}%
-\caption{What happens with very large floating point numbers in \python?\pythonIdx{inf}}%
-\label{fig:floatMathInConsoleInf}%
-\end{figure}%
+\gitEvalPython{float_very_large}{}{simple_datatypes/float_very_large.py}%
+\listingBox{exec:float_very_large}{What happens with very large floating point numbers in \python?\pythonIdx{inf}.}{,style=python_console_style,literate={0}{0\-}1 {1}{1\-}1 {2}{2\-}1 {3}{3\-}1 {4}{4\-}1 {5}{5\-}1 {6}{6\-}1 {7}{7\-}1 {8}{8\-}1 {9}{9\-}1,breakatwhitespace=false,breaklines=true}
 
 But what happens to numbers that are too big for the available range?
 Again, according to the nice documentation of \pgls{Java}, the maximum 64~bit double precision floating point number value is~$(2-2^{-52})*2^{1023}\approx1.797\decSep693\decSep134\decSep862\decSep315\decSep708\dots*10^{308}$.
-We can enter this value as \pythonilIdx{1.7976931348623157e+308}\pythonIdx{float!largest} and it indeed prints correctly in \cref{fig:floatMathInConsoleInf}.
+We can enter this value as \pythonilIdx{1.7976931348623157e+308}\pythonIdx{float!largest} and it indeed prints correctly in \cref{exec:float_very_large}.
 If we step it up a little bit and enter \pythonil{1.7976931348623158e+308}, due to the limited precision, we again get \pythonilIdx{1.7976931348623157e+308}\pythonIdx{float!largest}.
 However, if we try entering \pythonil{1.7976931348623159e+308} into the \python\ console, something strange happens:
 The output is \pythonilIdx{inf}.
@@ -391,15 +375,11 @@
 We can import it via \pythonil{from math import inf}\pythonIdx{inf}.
 And indeed, since the text \pythonil{1.7976931348623159e+308} is parsed to a \pythonilIdx{float} value of \pythonilIdx{inf}, we find that \pythonil{1.7976931348623159e+308 == inf} yields~\pythonilIdx{True}.
 
-\begin{figure}%
-\centering%
-\includegraphics[width=0.8\linewidth]{\currentDir/floatMathInConsoleNaN}%
-\caption{Not a Number\pythonIdx{Not a Number}, i.e., \pythonilIdx{nan}.}%
-\label{fig:floatMathInConsoleNaN}%
-\end{figure}%
-list
+\gitEvalPython{float_nan}{}{simple_datatypes/float_nan.py}%
+\listingBox{exec:float_nan}{Not a Number\pythonIdx{Not a Number}, i.e., \pythonilIdx{nan}.}{,style=python_console_style}%
+
 Now, \pythonilIdx{inf} not actually being~$\infty$ is a little bit weird.
-But it can get even stranger, as you will see in \cref{fig:floatMathInConsoleNaN}.
+But it can get even stranger, as you will see in \cref{exec:float_nan}.
 \pythonilIdx{inf} is a number which is too big to be represented as \pythonilIdx{float} \emph{or}~$\infty$.
 So it is natural to assume that \pythonil{inf - 1} remains \pythonilIdx{inf} and that even \pythonil{inf - 1e300} remains \pythonilIdx{inf} as well.
 However, what is \pythonil{inf - inf}?
@@ -421,16 +401,12 @@
 However, \pythonilIdx{nan} is \emph{really} different from really \emph{anything}.
 Therefore, \pythonil{nan == nan}\pythonIdx{==} is \pythonilIdx{False} and \pythonil{nan != nan}\pythonIdx{"!=} is \pythonilIdx{True}!
 
-\begin{figure}%
-\centering%
-\includegraphics[width=0.8\linewidth]{\currentDir/floatMathInConsoleCheckFinite}%
-\caption{Checking for \pythonilIdx{nan} and \pythonilIdx{inf} via \pythonilIdx{isfinite}, \pythonilIdx{isinf}, and \pythonilIdx{isnan}.}%
-\label{fig:floatMathInConsoleCheckFinite}%
-\end{figure}%
+\gitEvalPython{float_check_finite}{}{simple_datatypes/float_check_finite.py}%
+\listingBox{exec:float_check_finite}{Checking for \pythonilIdx{nan} and \pythonilIdx{inf} via \pythonilIdx{isfinite}, \pythonilIdx{isinf}, and \pythonilIdx{isnan}.}{,style=python_console_style}%
 
 Either way, the possible occurrence \pythonilIdx{inf} and \pythonilIdx{nan} in floating point computations is a cumbersome issue.
 If we want to further process results of a computation, we often want to make sure that it is neither \pythonilIdx{inf} nor \pythonilIdx{-inf} nor \pythonilIdx{nan}.
-This can be done via the function \pythonilIdx{isfinite}, which we can import from the \pythonilIdx{math} module\pythonIdx{import}\pythonIdx{from}, as you can see in \cref{fig:floatMathInConsoleCheckFinite}.
+This can be done via the function \pythonilIdx{isfinite}, which we can import from the \pythonilIdx{math} module\pythonIdx{import}\pythonIdx{from}, as you can see in \cref{exec:float_check_finite}.
 \pythonil{1e34} is a large number, but \pythonil{isfinite(1e34)} is certainly \pythonilIdx{True}.
 \pythonil{isfinite(inf)} and \pythonil{isfinite(nan)} are both \pythonilIdx{False}.
 The function \pythonilIdx{isinf}, again from the \pythonilIdx{math} module, checks if a \pythonilIdx{float} is infinite.

text/main/basics/simpleDataTypesAndOperations/float/floatMathInConsoleCheckFinite.pdf

@@ -24,21 +24,21 @@
 \begin{figure}%
 \centering%
 \includegraphics[width=0.8\linewidth]{\currentDir/pythonIntMathInConsoleArith}%
-\caption{Examples of \python\ integer math in the console, part~1 (see \cref{exec:int_math_arith} for part~2).}%
+\caption{Examples of \python\ integer math in the console, part~1 (see \cref{exec:int_arithmetics} for part~2).}%
 \label{fig:pythonIntMathInConsoleArith}%
 \end{figure}%
 %
-\gitEvalPython{int_math_arith}{}{simple_datatypes/int_math_arith.py}%
-\listingBox{exec:int_math_arith}{The same examples of \python\ integer math in the \python\ console as given in \cref{fig:pythonIntMathInConsoleArith}, just as listing instead of screenshot.}{,style=python_console_style}%
+\gitEvalPython{int_arithmetics}{}{simple_datatypes/int_arithmetics.py}%
+\listingBox{exec:int_arithmetics}{The same examples of \python\ integer math in the \python\ console as given in \cref{fig:pythonIntMathInConsoleArith}, just as listing instead of screenshot.}{,style=python_console_style}%
 
 In \cref{fig:pythonIntMathInConsoleArith}, you can find some examples of this.
-(The same example is given in \cref{exec:int_math_arith}, just as listing instead of screenshot.
+(The same example is given in \cref{exec:int_arithmetics}, just as listing instead of screenshot.
 We will use such listings from now on, as they convey the exactly same information, but are easier to read and I can more conveniently include comments.)
 Like back in \cref{sec:terminalConsolem}, press \ubuntuTerminal\ under \ubuntu\ \linux\ or \windowsTerminal\ under \microsoftWindows\ to open a \pgls{terminal}.
 After entering \bashil{python3} and hitting \keys{\enter}, we can begin experimenting with integer maths.
 The lines with \python\ commands in the console begin with \pythonil{>>>}, whereas the result is directly output below them without prefix string.
 
-In the very first line of \cref{fig:pythonIntMathInConsoleArith,exec:int_math_arith}, we enter \pythonil{4 + 3}\pythonIdx{+} and hit \keys{\enter}.
+In the very first line of \cref{fig:pythonIntMathInConsoleArith,exec:int_arithmetics}, we enter \pythonil{4 + 3}\pythonIdx{+} and hit \keys{\enter}.
 The result is displayed on the next line and, as expected, is \pythonil{7}.
 We then attempt to multiply the two integers \pythonil{7} and \pythonil{5} by typing \pythonil{7 * 5}\pythonIdx{*!multiplication} and hitting \keys{\enter}.
 The result is \pythonil{35}.
@@ -70,10 +70,10 @@
 The remainder of this operation can be computed using the \pgls{modulodiv} operator \expandafter\pythonilIdx{\%}, i.e., by typing \pythonil{33 \% 4}, which yields~\pythonil{1}.
 We also find that \expandafter\pythonil{34 \% 4} yields~\pythonil{2}, \expandafter\pythonil{35 \% 4} gives us~\pythonil{3}, and \expandafter\pythonil{36 \% 4} is~\pythonil{0}.
 
-\gitEvalPython{int_math_power}{}{simple_datatypes/int_math_power.py}%
-\listingBox{exec:int_math_power}{Examples of \python\ integer math (powers) in the \python\ console, part~2 (see \cref{exec:int_math_arith} for part~1).}{,style=python_console_style,literate={0}{0\-}1 {1}{1\-}1 {2}{2\-}1 {3}{3\-}1 {4}{4\-}1 {5}{5\-}1 {6}{6\-}1 {7}{7\-}1 {8}{8\-}1 {9}{9\-}1,breakatwhitespace=false,breaklines=true}
+\gitEvalPython{int_powers}{}{simple_datatypes/int_powers.py}%
+\listingBox{exec:int_powers}{Examples of \python\ integer math (powers) in the \python\ console, part~2 (see \cref{exec:int_arithmetics} for part~1).}{,style=python_console_style,literate={0}{0\-}1 {1}{1\-}1 {2}{2\-}1 {3}{3\-}1 {4}{4\-}1 {5}{5\-}1 {6}{6\-}1 {7}{7\-}1 {8}{8\-}1 {9}{9\-}1,breakatwhitespace=false,breaklines=true}
 
-As you will find in \cref{exec:int_math_arith}, integers can also be raised to a power.
+As you will find in \cref{exec:int_arithmetics}, integers can also be raised to a power.
 For example, $2^7$~is expressed as \pythonil{2 ** 7}\pythonIdx{**!power} in \python\ (and yields~\pythonil{128}).
 \pythonil{7 ** 11}, i.e., $7^{11}$ gives us~1\decSep977\decSep326\decSep743 and shows as \pythonil{1977326743} in the output.
 
@@ -83,7 +83,7 @@
 In \python\, we can compute $2^{63}$~(\pythonil{2 ** 63}), namely 9\decSep223\decSep372\decSep036\decSep854\decSep775\decSep808, and
 $2^{64}$~(\pythonil{2 ** 64}), which is~18\decSep446\decSep744\decSep073\decSep709\decSep551\decSep616.
 These are very large numbers and the latter one would overflow the range of the standard integer types of \pgls{Java} and \pgls{C}.
-However, we can also keep going and compute \pythonil{2 ** 1024}, which is such a huge number that it wraps several times in the output of our \python\ console in \cref{exec:int_math_arith}!
+However, we can also keep going and compute \pythonil{2 ** 1024}, which is such a huge number that it wraps several times in the output of our \python\ console in \cref{exec:int_arithmetics}!
 \python\ integers are basically unbounded~(or bounded only by the memory size of our computer).
 However, the larger they get, the more memory they need and the longer it will take to compute with them.
 \endhsection%
@@ -103,8 +103,8 @@
 \caption{Examples for how integer numbers are represented as bit strings in the computer (upper part) and for the binary (bitwise) operations \emph{and}, \emph{or}, and \emph{exclusive or} (often called~\emph{xor}).}%
 \label{fig:binaryMath}%
 \end{figure}
-\gitEvalPython{int_math_bin}{}{simple_datatypes/int_math_bin.py}%
-\listingBox{exec:int_math_bin}{Examples of the binary representation of integers and the operations that apply to it.}{,style=python_console_style}
+\gitEvalPython{int_binary}{}{simple_datatypes/int_binary.py}%
+\listingBox{exec:int_binary}{Examples of the binary representation of integers and the operations that apply to it.}{,style=python_console_style}
 
 All integer numbers can be represented as bit strings.
 In other words, a number $z\in\integerNumbers$ can be expressed as $b_0 2^0 + b_1 2^1 + b_2 2^2 + b_3 2^3 + b_4 2^4\dots$, where the $b_i$-values each are either~0 or~1.
@@ -113,7 +113,7 @@
 In in \cref{fig:binaryMath}, we illustrate that the number~22 would be \texttt{10110} because $22=2^4+2^2+2^1$ and the number~15 would correspond to \texttt{01111}, as~$15=2^3+2^2+2^1+2^0$.
 
 We can obtain the binary representation of integer numbers as text using the \pythonilIdx{bin} function in \python.
-As shown in \cref{exec:int_math_bin}, \pythonil{bin(22)} yields \pythonil{'0b10110'}.
+As shown in \cref{exec:int_binary}, \pythonil{bin(22)} yields \pythonil{'0b10110'}.
 Here, the \pythonilIdx{0b} prefix means that the following number is in binary representation.
 We can also enter numbers in binary representation in the console.
 Typing \pythonil{0b10110} corresponds to the number~\pythonil{22}.