improved fraction section

Author: thomasWeise

README.md

@@ -65,8 +65,10 @@ Die Slides zum Kurs in deutscher Sprache können unter <https://thomasweise.gith
 40. [Operationen für Iteratoren](https://thomasweise.github.io/programmingWithPythonSlidesDE/40_operationen_für_iteratoren.pdf)
 41. [Klassen: Grundlagen](https://thomasweise.github.io/programmingWithPythonSlidesDE/41_klassen_grundlagen.pdf)
 42. [Klassen: Kapselung](https://thomasweise.github.io/programmingWithPythonSlidesDE/42_klassen_kapselung.pdf)
+43. [Klassen: Vererbung](https://thomasweise.github.io/programmingWithPythonSlidesDE/43_klassen_vererbung.pdf)
 44. [Klassen/Dunder: `__str__`, `__repr__`, und `__eq__`](https://thomasweise.github.io/programmingWithPythonSlidesDE/44_klassen_dunder_str_rep_eq.pdf)
 45. [Klassen/Dunder: `__hash__`](https://thomasweise.github.io/programmingWithPythonSlidesDE/45_klassen_dunder_hash.pdf)
+46. [Klassen/Dunder: Arithmetische Operatoren und Vergleiche](https://thomasweise.github.io/programmingWithPythonSlidesDE/46_klassen_dunder_math.pdf)
 
 
 ### 2.3. The Slides in English

text/main/classes/dunder/dunder.tex

@@ -384,16 +384,17 @@
 \hsection{Arithmetic Dunder and Ordering}%
 \label{sec:arithmeticsAndOrder}%
 %
+\gitLoadPython{dunder:fraction}{}{dunder/fraction.py}{}%
 \gitLoadPython{dunder:fraction:part_1}{}{dunder/fraction.py}{--args format --labels part_1}%
 \listingPython{dunder:fraction:part_1}{%
 Part~1 of the \pythonil{Fraction} class: The initializer \dunder{init} and global constants.}%
 \afterpage{\clearpage}%
 %
-Much of \python's syntactic behavior can be grounded on dunder methods.
+Much of the actual behavior of \python's syntactx is implemented by dunder methods.
 Indeed, even the arithmetic operators~\pythonilIdx{+}, \pythonilIdx{-}, \pythonilIdx{*}, and \pythonilIdx{/}.
 This allows us to define new numerical types if we want.
 
-Here, we will do exactly that:
+And since we did a lot of math-nerdery in this book already {\dots} of course we want that!
 We implement the basic arithmetic operations for a class~\pythonil{Fraction} that represents fractions~$q\in\rationalNumbers$, i.e., it holds that~$q=\frac{a}{b}$ with~$a,b\in\integerNumbers$ and~$b\neq0$.\footnote{
 \python\ already has such a type built-in. %
 Our goal here is to explore dunder methods, so we make our own class instead. %
@@ -402,17 +403,19 @@
 In other words, we want to pour primary school mathematics into a new numerical type.
 To refresh our memory, $a$~is called the \pgls{numerator} and $b$~is called the \pgls{denominator} of the fraction~$\frac{a}{b}$.
 
+Let's start implementing our class \pythonil{Fraction} in file \programUrl{dunder:fraction}.
 The overall code for this class is a bit longer compared to our previous examples.
 We therefore split it into several parts, namely~\cref{lst:dunder:fraction:part_1,lst:dunder:fraction:part_2,lst:dunder:fraction:part_3,lst:dunder:fraction:part_4,lst:dunder:fraction:part_5} (and later add \cref{lst:dunder:fraction:part_6}).
 At first we need to decide which attributes such a class would need.
 We construct the initializer dunder method \dunder{init} in \cref{lst:dunder:fraction:part_1}.
 
-Since the fraction~$\frac{a}{b}$ can be defined by the two integer numbers~$a$ and~$b$, it makes sense to also have two \pythonil{int} attributes~\pythonil{a} and~\pythonil{b} in our~\pythonil{Fraction} class.
-We want our numbers to be immutable, because like you cannot change the value of~\pythonil{5}, you should also not be able to change the value of~\pythonil{1/3}.
+Since the fraction~$\frac{a}{b}$ can be defined by the two integer numbers~$a$ and~$b$, it makes sense to also have two \pythonil{int} attributes~\pythonil{a} and~\pythonil{b}.
+We want our fractions to be immutable.
+You cannot change the value of~\pythonil{5}, and you should also not be able to change the value of~\pythonil{1/3}.
 The attributes will therefore receive the \pgls{typeHint} \pythonilIdx{Final[int]}~\cite{PEP591}.
 
 Our fractions should be \emph{canonical}.
-It is totally possible that two fractions~$\frac{a}{b}=\frac{c}{d}$ with $a\neq c$ or $b\neq c$.
+It is totally possible that two fractions~$\frac{a}{b}=\frac{c}{d}$ with $a\neq c$ and $b\neq c$.
 This is the case for, let's say, $\frac{-9}{3}$ and $\frac{12}{-4}$.
 In such cases we want to ideally store them in objects that have exactly the same attribute values.
 
@@ -427,7 +430,7 @@
 This leaves only the question where the sign should be stored.
 Obviously, $\frac{-5}{2}=\frac{5}{-2}$ and $\frac{5}{2}=\frac{-5}{-2}$.
 We decide that the sign of the fraction is always stored in the attribute~\pythonil{a}.
-In other words, if $\frac{a}{b}<0$, then \pythonil{a} will be negative, otherwise it should be positive.
+In other words, if $\frac{a}{b}<0$, then \pythonil{a} will be negative, otherwise it should be positive or~0.
 It can only be that $\frac{a}{b}<0$ if exactly one of $a<0$ or $b<0$ is true.
 Therefore, the sign of our fraction is determined by \pythonil{-1 if ((a < 0) != (b < 0)) else 1}.
 
@@ -439,9 +442,10 @@
 Then we need to check whether our canonicalization by dividing with the \pythonilIdx{gcd} correctly maps~$\frac{12}{2}$ to~$\frac{6}{1}$.
 And we need to verify that~$\frac{2}{-12}$ and~$\frac{-2}{12}$ correctly become~$\frac{-1}{6}$ while $\frac{-2}{-12}$~becomes~$\frac{1}{6}$.
 The special case of the number zero also needs to be checked:
-We know that \pythonil{gcd(0, -9) = -9}, so it should work, but it is better to verify that~$\frac{0}{-9}$ is indeed mapped to~$\frac{0}{1}$.
+We know that \pythonil{gcd(0, -9) = -9}, so $\frac{0}{-9}$ should become $\frac{0}{1}$.
+Still, it is better to verify that.
 Finally, we need to verify that the \pythonilIdx{ZeroDivisionError} is indeed raised when we try to instantiate \pythonil{Fraction} with a zero \pgls{denominator}.
-Without needing to read the actual code of \pythonil{\_\_init\_\_}, a user can therefore already learn a lot about how our class \pythonil{Fraction} represents rational numbers just from the \pglspl{doctest}.
+Without needing to read the actual code of \dunder{init}, a user can therefore already learn a lot about how our class \pythonil{Fraction} represents rational numbers just from the \pglspl{doctest}.
 
 Several special fractions will occur very often in computations.
 Instead of creating them again and again, we can define them as constants.
@@ -470,17 +474,24 @@
 This was because we did not yet define the \dunder{str} and \dunder{repr} methods for our class \pythonil{Fraction}.
 We do this in \cref{lst:dunder:fraction:part_2}.
 The method \dunder{str} is supposed to return a compact representation of the fractions.
-We implement such that it returns \pythonil{self.a} as string if the \pgls{denominator} is one, i.e., if~\pythonil{self.b == 1}.
+We implement it such that it returns \pythonil{self.a} as string if the \pgls{denominator} is one, i.e., if~\pythonil{self.b == 1}.
+Because then the fraction is actual an integer number.
 Otherwise, it should return \pythonil{f"\{self.a\}/\{self.b\}"}.
+
 This is easy and clear enough for each user to immediately recognize the value of the fraction.
-It is also ambiguous, though, because one cannot distinguish \pythonil{str(Fraction(12, 1))} from \pythonil{str(12)}, i.e., fractions that represent integer numbers will produce the same strings as integer numbers.
+It is also ambiguous, though, because one cannot distinguish \pythonil{str(Fraction(12, 1))} from \pythonil{str(12)}.
+Fractions that represent integer numbers will produce the same strings as these integer numbers.%
+%
+\begin{sloppypar}%
 The \dunder{repr} method exists to produce unambiguous output.
-We implement it to return~\pythonil{f\"Fraction(\{self.a\}, \{self.b\})"}.
-
+We implement it to return~\pythonil{f\"Fraction(\{self.a\}, \{self.b\})\"}.%
+\end{sloppypar}%
+%
 In the \pglspl{docstring} of both methods, we include \pglspl{doctest}.
-Notice that \dunder{str} is used if pass an object to~\pythonilIdx{print}.
+Notice that \dunder{str} is used automatically if pass an object to~\pythonilIdx{print}.
 This means that we can compare the expected output of \pythonil{f.\_\_str\_\_()} for a fraction~\pythonil{f} to the result of~\pythonil{print(f)}.
-Otherwise, \pglspl{doctest} always convert objects to string using~\pythonilIdx{repr}, meaning that the line~\pythonil{Fraction(-5, 12)} in the \pgls{doctest} of \dunder{repr} actually calls \pythonil{repr(Fraction(-5, 12)}.
+Otherwise, \pglspl{doctest} always convert objects to string using~\pythonilIdx{repr}.
+This means that the line~\pythonil{Fraction(-5, 12)} in the \pgls{doctest} of \dunder{repr} actually calls \pythonil{repr(Fraction(-5, 12)}.
 Anyway, with the string conversion out of the way, we can begin to implement mathematical operators.
 
 \gitLoadPython{dunder:fraction:part_3}{}{dunder/fraction.py}{--args format --labels part_3}%
@@ -495,36 +506,41 @@
 
 In \cref{lst:dunder:fraction:part_3}, we want to enable our \pythonil{Fraction} class to be used with the \pythonil{+} and \pythonil{-} operators.
 In \python, doing something like \pythonil{x + y} will invoke \pythonil{x.\_\_add\_\_(y)}, if the class of~\pythonil{x} defines the \dunder{add} method.
-From primary school, we remember that $\frac{a}{b}+{c}{d} = \frac{a*d+c*b}{b*d}$.
-Therefore, if \pythonil{other} is also an instance\pythonIdx{isinstance} of \pythonil{Fraction}, \pythonil{\_\_add\_\_(other)} computes the result like that and creates a new \pythonil{Fraction}.
+From primary school, we remember that $\frac{a}{b}+\frac{c}{d} = \frac{a*d+c*b}{b*d}$, for~$b,d\neq0$.
+Therefore, if \pythonil{other} is also an instance\pythonIdx{isinstance} of \pythonil{Fraction},  then \pythonil{\_\_add\_\_(other)} computes the result like that and creates a new \pythonil{Fraction}.
 Notice that the initializer of that new fraction will automatically normalize the fraction by using~\pythonilIdx{gcd}.
-If \pythonil{other} is not an instance of \pythonil{Fraction}, we return \pythonilIdx{NotImplemented}, because this would enable \python\ to look for other routes to perform addition with our objects.\footnote{%
-\python\ would then look whether \pythonil{other} provides an \pythonilIdx{\_\_radd\_\_}\pythonIdx{dunder!\_\_radd\_\_} method that does not return~\pythonilIdx{NotImplemented} {\dots} but we will not implement all possible arithmetic dunder methods here so we skip this one.%
-}%
-The behavior of this method is again be tested with \pglspl{doctest}.
-These check that $\frac{1}{3} + \frac{1}{2}$ actually yields~$\frac{5}{6}$ and that $\frac{1}{2}+\frac{1}{2}$ really returns~$\frac{1}{1}$.
-They also check correct normalization by trying~$\frac{21}{-12}+\frac{-33}{42}=\frac{882+396}{-504}=\frac{1278}{-504}=\frac{18*1278}{18*-28}=\frac{-71}{28}$.
+
+If \pythonil{other} is not an instance of \pythonil{Fraction}, we return \pythonilIdx{NotImplemented}.
+We already know this from our implementation of \dunder{eq} for points.
+This result enables \python\ to look for other routes to perform addition with our objects.
+Here, \python\ would then look whether \pythonil{other} provides a \dunder{radd} method that does not return~\pythonilIdx{NotImplemented} {\dots} but we will not implement all possible arithmetic dunder methods here so we skip this one.
+
+Either way, the behavior of this method is again be tested with \pglspl{doctest}.
+These tests check that $\frac{1}{3} + \frac{1}{2}$ actually yields~$\frac{5}{6}$.
+We test whether  $\frac{1}{2}+\frac{1}{2}$ really returns~$\frac{1}{1}$.
+Then we also check correct normalization by trying whether~$\frac{21}{-12}+\frac{-33}{42}=\frac{882+396}{-504}=\frac{1278}{-504}=\frac{18*1278}{18*-28}=\frac{-71}{28}$.
 
 After confirming that these tests succeed, we continue by implementing the \dunder{sub} method in exactly the same way.
 This enables subtraction by using~\pythonilIdx{-}, because \pythonil{x - y} will invoke \pythonil{x.\_\_sub\_\_(y)}, if the class of~\pythonil{x} defines the \dunder{sub} method.
-Clearly, $\frac{a}{b}-{c}{d} = \frac{a*d-c*b}{b*d}$.
-As \pglspl{doctest}, the same three cases as used for \pythonil{\_\_add\_\_} will do.
+Clearly, $\frac{a}{b}-\frac{c}{d} = \frac{a*d-c*b}{b*d}$ for~$b,d\neq0$.
+As \pglspl{doctest}, the same three cases as used for \dunder{add} will do.
 
 In \cref{lst:dunder:fraction:part_4}, we now focus on multiplication and division.
-The \pythonil{*}~operation will utilize a \dunder{mul}, if implemented, and that \pythonil{/}~operation uses \dunder{truediv}.
-Multiplying the fractions~$\frac{a}{b}$ and~$\frac{c}{d}$ yields~$\frac{a*c}{b*d}$.
-Dividing~$\frac{a}{b}$ by~$\frac{c}{d}$ yields~$\frac{a*d}{b*c}$.
+The \pythonil{*}~operation will utilize the method \dunder{mul}, if implemented.
+The \pythonil{/}~operation uses the method \dunder{truediv}, if implemented.
+Multiplying the fractions~$\frac{a}{b}$ and~$\frac{c}{d}$ yields~$\frac{a*c}{b*d}$ for $b,d\neq0$.
+Dividing~$\frac{a}{b}$ by~$\frac{c}{d}$ yields~$\frac{a*d}{b*c}$ for $b,c,d\neq0$.
 The dunder methods can be implemented according to the same schematic as before.
 We test multiplication by confirming that $\frac{6}{19}*\frac{3}{-7}=\frac{6 * 3}{19*-7}=\frac{18}{-133}=\frac{-18}{133}$.
 The division is tested by computing whether $\frac{6}{19}*\frac{3}{-7}=\frac{6 * -7}{19*3}=\frac{-42}{57}=\frac{3*-14}{3*19}$ indeed gives us~$\frac{-14}{19}$.
 
 Now we also implement support for the \pythonilIdx{abs} function.
 \pythonilIdx{abs} returns the absolute value of a number.
 Therefore, $\pythonil{abs(5)}=\pythonil{abs(-5)}=\pythonil{5}$.
-If present, \pythonil{abs(x)} will invoke~\pythonil{x.\_\_abs\_\_()}\pythonIdx{\_\_abs\_\_}\pythonIdx{dunder!\_\_abs\_\_}.
+\pythonil{abs(x)} will invoke~\pythonil{x.\_\_abs\_\_()}\pythonIdx{\_\_abs\_\_}\pythonIdx{dunder!\_\_abs\_\_}, if present.
 We can implement this method as follows:
 If our fraction is positive, then it can be returned as-is.
-Otherwise, we return a new, positive variant of our fraction by simply flipping the sign of it.
+Otherwise, we return a new, positive variant of our fraction.
 
 \gitLoadPython{dunder:fraction:part_5}{}{dunder/fraction.py}{--args format --labels part_5}%
 \listingPython{dunder:fraction:part_5}{%
@@ -551,28 +567,39 @@
 \end{itemize}%
 %
 Implementing equality and inequality is rather easy, since our fractions are all normalized.
-For two fractions~\pythonil{x} and~\pythonil{y}, it holds only that~\pythonil{x == y} if \pythonil{x.a == y.a} and \pythonil{x.b == y.b}.
+For two fractions~\pythonil{x} and~\pythonil{y}, it holds that~\pythonil{x == y} if and only if \pythonil{x.a == y.a} and \pythonil{x.b == y.b}.
 \dunder{eq} is thus quickly implemented.
 \dunder{ne} is its complement for the \pythonil{!=}\pythonIdx{"!=}~operator.
 \pythonil{x != y} is \pythonil{True} if either \pythonil{x.a != y.a} or \pythonil{x.b != y.b}.
 
 The other four comparison methods can be implemented by remembering how we used the common \pgls{denominator} for addition and subtraction.
 We did addition like this:~$\frac{a}{b}+\frac{c}{d}=\frac{a*d}{b*d}+\frac{c*b}{b*d}=\frac{a*d+c*b}{b*d}$.
-Looking at this again, we realize that $\frac{a}{b}<\frac{c}{d}$ is the same as~$\frac{a*d}{b*d}<\frac{c*b}{b*d}$, which must be the same as~$a*d<c*b$.
+Looking at this again, we realize that $\frac{a}{b}<\frac{c}{d}$ is the same as~$\frac{a*d}{b*d}<\frac{c*b}{b*d}$.
+This, in turn, must be the same as~$a*d<c*b$.
 Thus, $\frac{a}{b}\leq\frac{c}{d}$ is the same as~$a*d\leq c*b$.
 The greater and greater-or-equal operations can be defined the other way around.
 
 All six comparison operations are defined accordingly in \cref{lst:dunder:fraction:part_5}.
 This time, I omitted \pglspl{doctest} for the sake of space.
 Matter of fact, I have shortened the code and tests in all of the above code snippets.
-For example, we do not check whether the parameters of the initializer \dunder{init} are actually integers (and raise a \pythonilIdx{TypeError} otherwise).
-Such checks should then be covered by \pglspl{doctest}.
-You should never omit such checks and tests, because in program code, you \emph{do} have space.
+For example, we do not check whether the parameters of the initializer \dunder{init} are actually integers~(and raise a \pythonilIdx{TypeError} otherwise).
+
+Such checks should then be covered by additional \pglspl{unitTest}.
+You should never omit such checks and tests.
+In your program code, you \emph{do} have space.
+You can also pack them into additional modules.
 Your code does not need to fit on book pages\dots
 
 Anyway, in \cref{exec:dunder:fraction:doctest} we present the output of \pytest\ running the \pglspl{doctest} of all the methods we implemented.
 All of them succeed.
 This means that we can be fairly confident that using our \pythonil{Fraction} class in real computations would provide us correct results.%
+
+There are quite a few more dunder methods for implementing arithmetic operations.
+And this truly is a fun thing to do.
+We can have our classes for fractions and complex numbers.
+Well, \python\ already has those.
+But we could have complex numbers based on fractions.
+The sky is the limit!%
 \FloatBarrier%
 \endhsection%
 %