Updates from Overleaf

HappyCerberus · HappyCerberus · commit 9899c8a55d0b · 2022-09-05T20:15:04.000+02:00
diff --git a/book.tex b/book.tex
@@ -4,7 +4,7 @@
 %\usepackage{showframe}
 %\checkandfixthelayout
 
-\newcommand{\version}{0.2.1}
+\newcommand{\version}{0.3.0}
 \usepackage{hyperref}
 \hypersetup{
     colorlinks=true,
@@ -33,7 +33,7 @@
 \frontmatter
 \input{chapters/00_title_page}
 
-\input{chapters/01_preface} % In review
+\input{chapters/01_preface} % Reviewed
 
 \mainmatter
 \tableofcontents
diff --git a/chapters/01_preface.tex b/chapters/01_preface.tex
@@ -4,17 +4,17 @@ \chapter{Preface}
 
 \section*{About this book}
 
-This book is a complete guide to the \CC standard algorithms. However, that might not mean much to you, so let me unpack this statement.
+This book is a complete guide to the \CC\,standard algorithms. However, that might not mean much to you, so let me unpack this statement.
 
 This book is a guide, as opposed to a reference, meaning that instead of describing every detail, the book concentrates on examples and pointing out notable, surprising, dangerous or interesting aspects of the different algorithms. Furthermore, unlike a reference, it is supposed to be read, for the most part, like a book in sequential order.
 
-\CC already has one canonical reference, the \CC standard, and for quick lookup, the \href{https://cppreference.com}{cppreference.com} wiki is a great source.
+\CC\,already has one canonical reference, the \CC\,standard, and for quick lookup, the \href{https://cppreference.com}{cppreference.com} wiki is a great source.
 
 The "complete" part of the statement refers to the width of coverage. The book covers all algorithms and relevant theory up to the \CC20 standard (the \CC23 standard is not finalized at the time of writing). All information is present only in sufficient depth required by the context. This depth limitation keeps the book's overall size reasonable and within the "guide" style.
 
 \section*{About the author}
 
-I am Šimon Tóth, the sole author of this book. My primary qualification is 20 years of \CC experience, with approximately 15 of those years \CC being my primary language in professional settings.
+I am Šimon Tóth, the sole author of this book. My primary qualification is 20 years of \CC\,experience, with approximately 15 of those years \CC\,being my primary language in professional settings.
 
 My background is HPC, spanning academia, big tech and startup environments. I have architected, built and operated systems of all scales, from single machine hardware supported high-availability to planet-scale services.\footnote{You can check my \href{https://cz.linkedin.com/in/simontoth}{LinkedIn profile} for a detailed view of my past career.}
 
diff --git a/chapters/02_introduction.tex b/chapters/02_introduction.tex
@@ -1,12 +1,12 @@
 \chapter{Introduction}
 
-The \CC standard library is arguably quite limited in its functionality. However, when it comes to data and number crunching, the \CC standard library provides a versatile toolkit of algorithms.
+The \CC\,standard library is arguably quite limited in its functionality. However, when it comes to data and number crunching, the \CC\,standard library provides a versatile toolkit of algorithms.
 
-If you are a \CC developer, good familiarity with \CC standard algorithms can save you a lot of effort and accidental bugs. Notably, whenever you see a raw loop in your code, you should question whether calling a standard algorithm wouldn't be a better solution (it usually is).
+If you are a \CC\,developer, good familiarity with \CC\,standard algorithms can save you a lot of effort and accidental bugs. Notably, whenever you see a raw loop in your code, you should question whether calling a standard algorithm wouldn't be a better solution (it usually is).
 
 \section{History of standard \texorpdfstring{\CC}{C++} algorithms}
 
-While each \CC standard introduced new algorithms or variants, there are few notable milestones in the history of \CC standard algorithms.
+While each \CC\,standard introduced new algorithms or variants, there are few notable milestones in the history of \CC\,standard algorithms.
 
 The \CC98 standard introduced most of the algorithms. However, it was the \CC11 standard with its introduction of lambdas that made algorithms worthwhile. Before lambdas, the time investment of writing a custom function object made the usefulness of algorithms dubious.
 
@@ -44,7 +44,7 @@ \section{Iterators and ranges}
 
 Algorithms operate on data structures, which poses an issue. How do you abstract the implementation details of a specific data structure and allow the algorithm to work with any data structure that satisfies the algorithm's requirements?
 
-The \CC standard library solution to this problem are iterators and ranges. Iterators encapsulate implementation details of data structure traversal and simultaneously expose a set of operations possible on the given data structure in constant time and space.
+The \CC\, standard library solution to this problem are iterators and ranges. Iterators encapsulate implementation details of data structure traversal and simultaneously expose a set of operations possible on the given data structure in constant time and space.
 
 A range is then denoted by a pair of iterators, or more generally, since \CC20, an iterator and a sentinel. In mathematical terms, a pair of iterators \cpp{it1}, \cpp{it2} denotes a range \cpp{[it1, it2)}, that is, the range includes the element referenced by \cpp{it1} and ends before the element referenced by \cpp{it2}.
 
@@ -121,4 +121,16 @@ \subsection{Restrictions on invocable}
 
 These restrictions in practice mean that the passed invocable must be regular. The invocable must return the same result if invoked again with the same arguments. This definition permits accessing a global state such as a cache but does not permit invocables that change their result based on their internal state (such as generators).
 
-\section{A simple mental model for iterators}
+\section{A simpler mental model for iterators}
+
+It can be tricky to internalize all the rules associated with iterators when working with standard algorithms. One shorthand that can help is to think in terms of ranges instead of iterators.
+
+Ranges passed in as arguments are usually apparent, typically specified by pair of iterators.
+
+
+
+The less obvious can be the ranges returned by the algorithms. In some cases, the range is evident from the algorithm.
+
+In some cases, a single returned iterator denotes multiple ranges.
+
+Even when the algorithms seem to return an iterator to a specific element, we can still think of the output as a range.
diff --git a/chapters/03_algorithms_14_uninitialized.tex b/chapters/03_algorithms_14_uninitialized.tex
@@ -21,7 +21,7 @@ \subsection{\texorpdfstring{\cpp{std::construct_at}, \cpp{std::destroy_at}}{\tex
 \cppfile{code_examples/algorithms/create_at_code.h}
 \end{box-note}
 
-\subsection{\texorpdfstring{\cpp{std::uninitialized_default_construct},\newline\cpp{std::uninitialized_value_construct},\newline\cpp{std::uninitialized_fill}, \newline\cpp{std::destroy}}{\texttt{std::uninitialized\_default\_construct},\newline\texttt{std::uninitialized_value_construct},\newline\texttt{std::uninitialized_fill}, \newline\texttt{std::destroy}}}
+\subsection{\texorpdfstring{\cpp{std::uninitialized_default_construct},\newline\cpp{std::uninitialized_value_construct},\newline\cpp{std::uninitialized_fill}, \newline\cpp{std::destroy}}{\texttt{std::uninitialized\_default\_construct},\newline\texttt{std::uninitialized\_value\_construct},\newline\texttt{std::uninitialized\_fill}, \newline\texttt{std::destroy}}}
 \index{\cpp{std::uninitialized_default_construct}}
 \index{\cpp{std::uninitialized_value_construct}}
 \index{\cpp{std::uninitialized_fill}}
diff --git a/chapters/03_algorithms_17_minmax.tex b/chapters/03_algorithms_17_minmax.tex
@@ -77,7 +77,8 @@ \subsection{\texorpdfstring{\cpp{std::clamp}}{\texttt{std::clamp}}}
 \cppfile{code_examples/algorithms/clamp_code.h}
 \end{box-note}
 
-\subsection{\texorpdfstring{\cpp{std::min_element}, \cpp{std::max_element}, \cpp{std::minmax_element}}{\texttt{std::min\_element}, \texttt{std::max\_element}, \texttt{std::minmax\_element}}}
+\subsection{\texorpdfstring{\cpp{std::min_element}, \cpp{std::max_element}, \newline\cpp{std::minmax_element}}{\texttt{std::min\_element}, \texttt{std::max\_element},
+\textCR\texttt{std::minmax\_element}}}
 \index{\cpp{std::min_element}}
 \index{\cpp{std::max_element}}
 \index{\cpp{std::minmax_element}}
diff --git a/chapters/04_ranges_in_depth.tex b/chapters/04_ranges_in_depth.tex
@@ -225,7 +225,7 @@ \subsection{\texorpdfstring{\cpp{std::views::all}}{\texttt{std::views::all}}}
 \cppfile{code_examples/views/all_code.h}
 \end{box-note}
 
-\subsection{\texorpdfstring{\cpp{std::views::split}, \cpp{std::views::lazy_split}, \cpp{std::views::join_view}}{\texttt{std::views::split}, \texttt{std::views::lazy\_split}, \texttt{std::views::join\_view}}}
+\subsection{\texorpdfstring{\cpp{std::views::split}, \cpp{std::views::lazy_split}, \newline\cpp{std::views::join_view}}{\texttt{std::views::split}, \texttt{std::views::lazy\_split}, \textCR\texttt{std::views::join\_view}}}
 \index{\cpp{std::views::split}}
 \index{\cpp{std::views::lazy_split}}
 \index{\cpp{std::views::join_view}}
diff --git a/packages/code_blocks.tex b/packages/code_blocks.tex
@@ -1,3 +1,4 @@
+% Overleaf botch. Normally we use minted files in the build folder, but Overleaf needs special care.
 \def\StripPrefix#1>{}
 \def\isOverleaf{\fi
     \def\overleafJobname{output}% overleaf defaults to 'output' as \jobname
@@ -19,6 +20,9 @@
 
 \newminted{cpp}{
     linenos=true,
+    firstnumber=1,
+    tabsize=4,
+    obeytabs,
     xleftmargin=1em,
     breaklines,
     fontsize=\footnotesize,
@@ -34,4 +38,6 @@
     breaklines,
     fontsize=\footnotesize,
     numbersep=0.75em
-}
+}
+
+\newmintinline[cpp]{cpp}{}
diff --git a/packages/color_blocks.tex b/packages/color_blocks.tex
@@ -1,43 +1,15 @@
 \usepackage[many]{tcolorbox}    	% for COLORED BOXES (tikz and xcolor included)
-\usepackage{xcolor}
-
-\tcbset{
-    sharp corners,
-    colback = white,
-    before skip = 0.2cm,    % add extra space before the box
-    after skip = 0.5cm      % add extra space after the box
-}                           % setting global options for tcolorbox
-
-\newtcolorbox{box-info}{
-    colback = LightSkyBlue!20, 
-    colframe = MidnightBlue!50, 
-    boxrule = 0pt, 
-    leftrule = 6pt, % left rule weight
-    fontupper=\sffamily
-}
-
-\newtcolorbox{box-warning}{
-    colback = LightGoldenrodYellow, 
-    colframe = LightGoldenrod, 
-    boxrule = 0pt, 
-    leftrule = 6pt, % left rule weight
-    fontupper=\sffamily
-}
-
-\newtcolorbox{box-critical}{
-    colback = LightSalmon!20, 
-    colframe = OrangeRed!80, 
-    boxrule = 0pt, 
-    leftrule = 6pt, % left rule weight
-    fontupper=\sffamily
-}
 
 \newtcolorbox{box-note}{
     sharpish corners, % better drop shadow
     boxrule = 0pt,
     toprule = 4.5pt, % top rule weight
     enhanced,
     breakable,
+    enlarge top by=5pt,
+    colback = white,
+    before skip = 0.2cm,    % add extra space before the box
+    after skip = 0.5cm,      % add extra space after the box
     drop fuzzy shadow = black!35,
     fontupper=\sffamily
 }
diff --git a/packages/local.tex b/packages/local.tex
@@ -1,5 +1,6 @@
-\usepackage{sidenotes}
-\usepackage{multirow}
+\usepackage{sidenotes} % Required
+\usepackage{multirow} % Required
+\usepackage{diagbox} % Used for boolean algorithms.
 
 % Command to consistently format side-panel with C++ versions that introduced different variants of the algorithm.
 \newcommand{\cppversions}[5]{
@@ -19,6 +20,7 @@
 \end{margintable}
 }
 
+% Command to consistently format the algorithm info table.
 \newcommand{\constraints}[4]{
 \begin{center}
 \footnotesize
@@ -45,8 +47,4 @@
 \hline
 \end{tabular}
 \end{center}
-}
-
-\newmintinline[cpp]{cpp}{}
-
-\usepackage{diagbox}
+}
diff --git a/packages/slashbox.sty b/packages/slashbox.sty
