From 3797a004013f0996130d118da334b604258080cd Mon Sep 17 00:00:00 2001 From: Thomas Scheffler Date: Fri, 28 Jun 2019 15:11:27 +0200 Subject: [PATCH] Version 1.10 --- .gitignore | 8 + ASCII.tex | 87 +++ Append1.tex | 212 +++++++ Chapter1.tex | 617 ++++++++++++++++++++ Chapter2.tex | 702 +++++++++++++++++++++++ Chapter3.tex | 735 ++++++++++++++++++++++++ Chapter4.tex | 481 ++++++++++++++++ Chapter5.tex | 935 ++++++++++++++++++++++++++++++ Chapter6_Iteration.tex | 730 ++++++++++++++++++++++++ Chapter7_Array.tex | 899 +++++++++++++++++++++++++++++ Chapter8_String.tex | 949 +++++++++++++++++++++++++++++++ Chapter9_Struct.tex | 550 ++++++++++++++++++ Main.tex | 238 ++++++++ Readme.md | 3 +- exercises/Exercise_1_english.tex | 98 ++++ exercises/Exercise_2_english.tex | 91 +++ exercises/Exercise_3_english.tex | 164 ++++++ exercises/Exercise_4_english.tex | 204 +++++++ exercises/Exercise_5_english.tex | 241 ++++++++ exercises/Exercise_6_english.tex | 109 ++++ exercises/Exercise_7_english.tex | 71 +++ exercises/Exercise_8_english.tex | 122 ++++ exercises/Exercise_9_english.tex | 103 ++++ figs/Compiler.pdf | Bin 0 -> 29160 bytes figs/Hint.pdf | Bin 0 -> 3745 bytes figs/Interpreter.pdf | Bin 0 -> 22403 bytes figs/assign2.pdf | Bin 0 -> 13038 bytes figs/point.pdf | Bin 0 -> 14818 bytes figs/rectangle.pdf | Bin 0 -> 20384 bytes figs/stack.pdf | Bin 0 -> 20220 bytes figs/stack2.pdf | Bin 0 -> 26652 bytes figs/stack4.pdf | Bin 0 -> 24444 bytes figs/stack_point2.pdf | Bin 0 -> 20978 bytes figs/stack_point3.pdf | Bin 0 -> 22385 bytes 34 files changed, 8348 insertions(+), 1 deletion(-) create mode 100644 .gitignore create mode 100644 ASCII.tex create mode 100644 Append1.tex create mode 100644 Chapter1.tex create mode 100644 Chapter2.tex create mode 100644 Chapter3.tex create mode 100644 Chapter4.tex create mode 100644 Chapter5.tex create mode 100644 Chapter6_Iteration.tex create mode 100644 Chapter7_Array.tex create mode 100644 Chapter8_String.tex create mode 100644 Chapter9_Struct.tex create mode 100644 Main.tex create mode 100644 exercises/Exercise_1_english.tex create mode 100644 exercises/Exercise_2_english.tex create mode 100644 exercises/Exercise_3_english.tex create mode 100644 exercises/Exercise_4_english.tex create mode 100644 exercises/Exercise_5_english.tex create mode 100644 exercises/Exercise_6_english.tex create mode 100644 exercises/Exercise_7_english.tex create mode 100644 exercises/Exercise_8_english.tex create mode 100644 exercises/Exercise_9_english.tex create mode 100644 figs/Compiler.pdf create mode 100644 figs/Hint.pdf create mode 100644 figs/Interpreter.pdf create mode 100644 figs/assign2.pdf create mode 100644 figs/point.pdf create mode 100644 figs/rectangle.pdf create mode 100644 figs/stack.pdf create mode 100644 figs/stack2.pdf create mode 100644 figs/stack4.pdf create mode 100644 figs/stack_point2.pdf create mode 100644 figs/stack_point3.pdf diff --git a/.gitignore b/.gitignore new file mode 100644 index 0000000..9030a51 --- /dev/null +++ b/.gitignore @@ -0,0 +1,8 @@ +.svn +*.log +*.out +*.toc +*.aux +*.idx +*.DS_Store +/takeouts diff --git a/ASCII.tex b/ASCII.tex new file mode 100644 index 0000000..103a02c --- /dev/null +++ b/ASCII.tex @@ -0,0 +1,87 @@ +% LaTeX source for textbook ``How to think like a computer scientist'' +% Copyright (C) 2009 Thomas Scheffler + + +\chapter{ASCII-Table} +\label{ASCII-Table} +\vskip -3em + +\begin{tabular}{|c|c|c|c||c|c|c|c|} +\hline +Dec & Hex & Oct & Character & Dec & Hex & Oct & Character\\ +\hline +0 & 0x00 & 000 & NUL & 32 & 0x20 & 040 & SP\\ +1 & 0x01 & 001 & SOH & 33 & 0x21 & 041 & ! \\ +2 & 0x02 & 002 & STX & 34 & 0x22 & 042 & "'\\ +3 & 0x03 & 003 & ETX & 35 & 0x23 & 043 & \# \\ +4 & 0x04 & 004 & EOT & 36 & 0x24 & 044 & \$ \\ +5 & 0x05 & 005 & ENQ & 37 & 0x25 & 045 & \% \\ +6 & 0x06 & 006 & ACK & 38 & 0x26 & 046 & \& \\ +7 & 0x07 & 007 & BEL & 39 & 0x27 & 047 & ' \\ +8 & 0x08 & 010 & BS & 40 & 0x28 & 050 & ( \\ +9 & 0x09 & 011 & TAB & 41 & 0x29 & 051 & ) \\ +10 & 0x0A & 012 & LF & 42 & 0x2A & 052 & * \\ +11 & 0x0B & 013 & VT & 43 & 0x2B & 053 & + \\ +12 & 0x0C & 014 & FF & 44 & 0x2C & 054 & , \\ +13 & 0x0D & 015 & CR & 45 & 0x2D & 055 & - \\ +14 & 0x0E & 016 & SO & 46 & 0x2E & 056 & . \\ +15 & 0x0F & 017 & SI & 47 & 0x2F & 057 & / \\ +16 & 0x10 & 020 & DLE & 48 & 0x30 & 060 & 0 \\ +17 & 0x11 & 021 & DC1 & 49 & 0x31 & 061 & 1 \\ +18 & 0x12 & 022 & DC2 & 50 & 0x32 & 062 & 2 \\ +19 & 0x13 & 023 & DC3 & 51 & 0x33 & 063 & 3 \\ +20 & 0x14 & 024 & DC4 & 52 & 0x34 & 064 & 4 \\ +21 & 0x15 & 025 & NAK & 53 & 0x35 & 065 & 5 \\ +22 & 0x16 & 026 & SYN & 54 & 0x36 & 066 & 6 \\ +23 & 0x17 & 027 & ETB & 55 & 0x37 & 067 & 7 \\ +24 & 0x18 & 030 & CAN & 56 & 0x38 & 070 & 8 \\ +25 & 0x19 & 031 & EM & 57 & 0x39 & 071 & 9 \\ +26 & 0x1A & 032 & SUB & 58 & 0x3A & 072 & : \\ +27 & 0x1B & 033 & ESC & 59 & 0x3B & 073 & ; \\ +28 & 0x1C & 034 & FS & 60 & 0x3C & 074 & "< \\ +29 & 0x1D & 035 & GS & 61 & 0x3D & 075 & =\\ +30 & 0x1E & 036 & RS & 62 & 0x3E & 076 & "> \\ +31 & 0x1F & 037 & US & 63 & 0x3F & 077 & ? \\ +\hline +\end{tabular} +\pagebreak + +\begin{longtable}{|c|c|c|c||c|c|c|c|} +\hline +Dec & Hex & Oct & Character & Dec & Hex & Oct & Character\\ +\hline +64 & 0x40 & 100 & @ & 96 & 0x60 & 140 & ` \\ +65 & 0x41 & 101 & A & 97 & 0x61 & 141 & a \\ +66 & 0x42 & 102 & B & 98 & 0x62 & 142 & b \\ +67 & 0x43 & 103 & C & 99 & 0x63 & 143 & c \\ +68 & 0x44 & 104 & D & 100 & 0x64 & 144 & d \\ +69 & 0x45 & 105 & E & 101 & 0x65 & 145 & e \\ +70 & 0x46 & 106 & F & 102 & 0x66 & 146 & f \\ +71 & 0x47 & 107 & G & 103 & 0x67 & 147 & g \\ +72 & 0x48 & 110 & H & 104 & 0x68 & 150 & h \\ +73 & 0x49 & 111 & I & 105 & 0x69 & 151 & i \\ +74 & 0x4A & 112 & J & 106 & 0x6A & 152 & j \\ +75 & 0x4B & 113 & K & 107 & 0x6B & 153 & k \\ +76 & 0x4C & 114 & L & 108 & 0x6C & 154 & l \\ +77 & 0x4D & 115 & M & 109 & 0x6D & 155 & m \\ +78 & 0x4E & 116 & N & 110 & 0x6E & 156 & n \\ +79 & 0x4F & 117 & O & 111 & 0x6F & 157 & o \\ +80 & 0x50 & 120 & P & 112 & 0x70 & 160 & p \\ +81 & 0x51 & 121 & Q & 113 & 0x71 & 161 & q \\ +82 & 0x52 & 122 & R & 114 & 0x72 & 162 & r \\ +83 & 0x53 & 123 & S & 115 & 0x73 & 163 & s \\ +84 & 0x54 & 124 & T & 116 & 0x74 & 164 & t \\ +85 & 0x55 & 125 & U & 117 & 0x75 & 165 & u \\ +86 & 0x56 & 126 & V & 118 & 0x76 & 166 & v \\ +87 & 0x57 & 127 & W & 119 & 0x77 & 167 & w \\ +88 & 0x58 & 130 & X & 120 & 0x78 & 170 & x \\ +89 & 0x59 & 131 & Y & 121 & 0x79 & 171 & y \\ +90 & 0x5A & 132 & Z & 122 & 0x7A & 172 & z \\ +91 & 0x5B & 133 & [ & 123 & 0x7B & 173 & \{ \\ +92 & 0x5C & 134 & $\backslash$ & 124 & 0x7C & 174 & $\mid$\\ +93 & 0x5D & 135 & ] & 125 & 0x7D & 175 & \} \\ +94 & 0x5E & 136 & \^{} & 126 & 0x7E & 176 & "~ \\ +95 & 0x5F & 137 & \_ & 127 & 0x7F & 177 & DEL \\ +\hline +\end{longtable} + diff --git a/Append1.tex b/Append1.tex new file mode 100644 index 0000000..93bb387 --- /dev/null +++ b/Append1.tex @@ -0,0 +1,212 @@ +% LaTeX source for textbook ``How to think like a computer scientist'' +% Copyright (C) 2009 Thomas Scheffler + + +\chapter{Coding Style} +\section{A short guide on style} +\index{style} +\index{coding style} + + +In the last few sections, I used the phrase ``by convention'' +several times to indicate design decisions that are arbitrary +in the sense that there are no significant reasons to do things +one way or another, but dictated by convention. + +In these cases, it is to your advantage to be familiar with +convention and use it, since it will make your programs easier +for others to understand. At the same time, it is important to +distinguish between (at least) three kinds of rules: + +\begin{description} + +\item[Divine law:] This is my phrase to indicate a rule that +is true because of some underlying principle of logic or +mathematics, and that is true in any programming language +(or other formal system). For example, there is no way to +specify the location and size of a bounding box using fewer +than four pieces of information. Another example is that adding +integers is commutative. That's part of the definition of +addition and has nothing to do with C. + +\item[Rules of C:] These are the syntactic and semantic +rules of C that you cannot violate, because the +resulting program will not compile or run. Some are arbitrary; +for example, the fact that the {\tt =} symbol represents +assignment and {\em not} equality. Others reflect +underlying limitations of the compilation or execution process. +For example, you have to specify the types of parameters, but +not arguments. + +\item[Style and convention:] There are a lot of rules that +are not enforced by the compiler, but that are essential for +writing programs that are correct, that you can debug and +modify, and that others can read. Examples include indentation +and the placement of squiggly braces, as well as conventions +for naming variables, functions and types. + +\end{description} + +In this section I will briefly summarize the coding style used within +this book. It follows loosely the "Nasa C Style Guide" +\footnote{www.scribd.com/doc/6878959/NASA-C-programming-guide} +and its main +intent is on readability rather than saving space or typing effort. + +%/ref +Since C has such a long history of usage, many +different coding styles have been developed and used. It is important +that you can read them and follow one particular scheme in all +your code. This makes it much more accessible should you find +yourself in a position where you have to share your work with other +people or have to access code written by your younger self - many years ago... + +\section{Naming conventions and capitalization rules} + +As a general rule, you should always choose meaningful names for +your identifiers. Ideally the name of a variable or function already explains +its behaviour or use. + +It may be more typing effort to use a function named {\tt FindSubString()} +rather than {\tt FndSStr()}. However, the former is almost self describing +and might save you a lot in debugging-time. + +\textbf{Don't use single letter variable names!} + +Similarly to functions, you should give your variables names that +speak for themselves and make clear what values will be stored +by this variable. +There are few noticeable exceptions to this rule: +People use {\tt i}, {\tt j} and {\tt k} as counter variables in loops and +for spacial coordinates people use {\tt x}, {\tt y} and {\tt z}. +Use these conventions if they suit you. Don't try to invent new +conventions all by yourself. + + +The following capitalization style shold be used for the different elements in your +program. The consistent use of one style gives the programmer and the reader +of the source code a quick way to determine the meaning of different items +in your program: + + +\begin{description} +\item[variableNames: ] variable names always start with lower-case, multiple +words are separated by capitalizing the first letter. +\item[CONSTANTS: ] use all upper case letters. In order to avoid name space +collisions it might be necessary to use a prefix such as {\tt MY\_CONSTANT}. +\item[FunctionNames:] start always with upper case and should possibly +contain a verb describing the function. Names for functions that test values should +start with '{\tt Is}' or '{\tt Are}'. +\item[UserDefinedTypes\_t:] always end in '{\tt \_t}'. Type names names must be +capitalised in order to avoid conflict with POSIX names. +\item[pointerNames\_p:] in order to visually separate pointer variables from +ordinary variables you should consider ending pointers with '{\tt \_p}'. +\end{description} + +%% +\section{Bracing style} + +There exist different bracing or indent styles that serve the goal +to make your code more readable through the use of a consistent +indentation for control block structures. +The styles differ in the way the braces are indented with the rest +of the control block. +This book uses the BSD/Allman Style because its is the most +readable of the four. It needs more horizontal space than the K\&R Style +but it makes it very easy to track opening and closing braces. + +When you are writing programs, make sure that you are using one +style consistently. In larger projects all contributors should agree +on the style they are using. Modern programming environments like +Eclipse support you through the automatic enforcement of a single style. + +\begin{verbatim} +/*Whitesmiths Style*/ + if (condition) + { + statement1; + statement2; + } +\end{verbatim} + +Is named after Whitesmiths C, an early commercial C compiler that +used this style in its examples. Some people refer to it as the +One True Brace Style. + +\begin{verbatim} + +/*GNU Style*/ + if (condition) + { + statement1; + statement2; + } +\end{verbatim} + +Indents are always four spaces per level, with the braces halfway between the outer and inner indent levels. + +\begin{verbatim} + +/*K&R/Kernel Style*/ + if (condition) { + statement1; + statement2; + } +\end{verbatim} + +This style is named after the programming examples in the book +\emph{The C Programming Language} by Brian W. Kernighan and +Dennis Ritchie (the C inventors). + +The K\&R style is the style that is hardest to read. +The opening brace happens to be at the far right side of the control statement +and can be hard to find. The braces therefore have different indentation levels. +Nevertheless, many C programs use this style. So you should be able +to read it. + +\begin{verbatim} + +/*BSD/Allman Style*/ + if (condition) + { + statement1; + statement2; + } +\end{verbatim} + +This style is used for all the examples in this book. + +\section{Layout} + +Block comments should be used at the top of your file, before all +function declarations, to explain the purpose of the program and give additional +information. + +You should also use a similar documentation style before every +relevant function in your program. +\begin{verbatim} + +/* + * File: test.c + * Author: Peter Programmer + * Date: May, 29th, 2009 + * + * Purpose: to demonstrate good programming + * practise + * / + +#include + +/* + * main function, does not use arguments + */ + +int main (void) +{ + return EXIT_SUCCESS; +} + +\end{verbatim} + + + diff --git a/Chapter1.tex b/Chapter1.tex new file mode 100644 index 0000000..98e7ab7 --- /dev/null +++ b/Chapter1.tex @@ -0,0 +1,617 @@ +% LaTeX source for textbook ``How to think like a computer scientist'' +% Copyright (C) 1999 Allen B. Downey +% Copyright (C) 2009 Thomas Scheffler + +\chapter{The way of the program} +\label{chap01} + +The goal of this book, and this class, is to teach you to think like a +computer scientist. I like the way computer scientists think because +they combine some of the best features of Mathematics, Engineering, +and Natural Science. Like mathematicians, computer scientists use formal +languages to denote ideas (specifically computations). Like +engineers, they design things, assembling components into systems and +evaluating tradeoffs among alternatives. Like scientists, +they observe the behavior of complex systems, form hypotheses, and test +predictions. + +The single most important skill for a computer scientist is {\bf +problem-solving}. By that I mean the ability to formulate problems, +think creatively about solutions, and express a solution clearly and +accurately. As it turns out, the process of learning to program is an +excellent opportunity to practice problem-solving skills. That's why +this chapter is called ``The way of the program.'' + +On one level, you will be learning to program, which is a useful +skill by itself. On another level you will use programming +as a means to an end. As we go along, that end will +become clearer. + +\section{What is a programming language?} +\index{programming language} +\index{language!programming} + +The programming language you will be learning is C, which was developed +in the early 1970s by Dennis M. Ritchie at the Bell Laboratories. C is +an example of a {\bf high-level language}; other high-level languages +you might have heard of are Pascal, C++ and Java. + +As you might infer from the name ``high-level language,'' there are +also {\bf low-level languages}, sometimes referred to as machine +language or assembly language. Loosely-speaking, computers can only +execute programs written in low-level languages. Thus, programs +written in a high-level language have to be translated before they can +run. This translation takes some time, which is a small disadvantage +of high-level languages. + +\index{portable} +\index{high-level language} +\index{low-level language} +\index{language!high-level} +\index{language!low-level} + +But the advantages are enormous. First, +it is {\em much} easier to program in a high-level language; +by ``easier'' I mean that the program takes less time to write, +it's shorter and easier to read, and it's more likely to be +correct. Secondly, high-level languages are {\bf portable}, +meaning that they can run on different kinds of computers with +few or no modifications. Low-level programs can only run +on one kind of computer, and have to be rewritten to run on +another. + +Due to these advantages, almost all programs are written in +high-level languages. Low-level languages are only used for +a few special applications. + +\index{compile} +\index{interpret} + +There are two ways to translate a program; +{\bf interpreting} or {\bf compiling}. An interpreter +is a program that reads a high-level program +and does what it says. In effect, it translates +the program line-by-line, alternately reading lines and +carrying out commands. + +\vskip 0.7em +\centerline{\includegraphics[height=3cm]{figs/Interpreter}} + +A compiler is a program that reads a high-level program and +translates it all at once, before executing any of the commands. +Often you compile the program as a separate step, and then +execute the compiled code later. In this case, the high-level +program is called the {\bf source code}, and the translated +program is called the {\bf object code} or the {\bf executable}. + +As an example, suppose you write a program in C. You might +use a text editor to write the program (a text editor is +a simple word processor). When the program is finished, you +might save it in a file named {\tt program.c}, where ``program'' +is an arbitrary name you make up, and the suffix {\tt .c} is +a convention that indicates that the file contains C source +code. + +Then, depending on what your programming environment is like, +you might leave the text editor and run the compiler. The +compiler would read your source code, translate it, and create +a new file named {\tt program.o} to contain the object code, +or {\tt program.exe} to contain the executable. + +\vskip 0.7em +\centerline{\includegraphics[height=3cm]{figs/Compiler}} + + +The next step is to run the program, which requires some kind of executor. +The role of the executor is to load the program (copy it from disk into memory) +and make the computer start executing the program. + + +Although this process may seem complicated, in most programming +environments (sometimes called development environments), these steps +are automated for you. Usually you will only have to write a program +and press a button or type a single command to compile and run it. On +the other hand, it is useful to know what the steps are that are +happening in the background, so that if something goes wrong you can +figure out what it is. + +% Leftover: when is compilation better than interpretation? + +\section{What is a program?} + +A program is a sequence of instructions that +specifies how to perform a computation. The computation might be +something mathematical, like solving a system of equations or finding +the roots of a polynomial, but it can also be a symbolic computation, +like searching and replacing text in a document or (strangely enough) +compiling a program. + +\index{statement} + +The instructions, which we will call {\bf statements}, look different +in different programming languages, but there are a few basic +operations most languages can perform: + +\begin{description} + +\item[input:] Get data from the keyboard, or a file, or some +other device. + +\item[output:] Display data on the screen or send data to a +file or other device. + +\item[math:] Perform basic mathematical operations like addition and +multiplication. + +\item[testing:] Check for certain conditions and execute the +appropriate sequence of statements. + +\item[repetition:] Perform some action repeatedly, usually with +some variation. + +\end{description} + +That's pretty much all there is to it. +Every program you've ever used, no matter how complicated, is +made up of statements that perform these operations. Thus, +one way to describe programming is the process of breaking a +large, complex task up into smaller and smaller subtasks +until eventually the subtasks are simple enough to be performed +with one of these basic operations. + +\section{What is debugging?} +\index{debugging} +\index{bug} + +Programming is a complex process, and since it is done by +human beings, it often leads to errors. For whimsical reasons, +programming errors are called {\bf bugs} and the process +of tracking them down and correcting them is called +{\bf debugging}. + +There are a few different kinds of errors that can occur +in a program, and it is useful to distinguish between them +in order to track them down more quickly. + +\subsection{Compile-time errors} +\index{compile-time error} +\index{error!compile-time} + +The compiler can only translate a program if the program is +syntactically correct; otherwise, the compilation fails and +you will not be able to run your program. {\bf Syntax} +refers to the structure of your program and the rules about +that structure. + +\index{syntax} + +For example, in English, a sentence must begin with a capital +letter and end with a period. this sentence contains a syntax +error. So does this one + +For most readers, a few syntax errors are not a significant +problem, which is why we can read the poetry of E.~E.~Cummings +without spewing error messages. + +Compilers are not so forgiving. If there is a single syntax +error anywhere in your program, the compiler will print an +error message and quit, and you will not be able to run +your program. + +To make matters worse, there are more syntax rules in C +than there are in English, and the error messages you get from +the compiler are often not very helpful. During the first +few weeks of your programming career, you will probably +spend a lot of time tracking down syntax errors. As you +gain experience, though, you will make fewer errors and find +them faster. + +\subsection{Run-time errors} +\label{run-time} +\index{run-time error} +\index{error!run-time} +%\index{exception} +\index{safe language} +\index{language!safe} + +The second type of error is a run-time error, so-called because +the error does not appear until you run the program. + +C is not a {\bf safe} language, such as Java, where +run-time errors are rare. Programming in C allows you to get very close to the actual +computing hardware. Most run-time errors C occur because the +language provides no protection against the accessing or +overwriting of data in memory. + +For the simple sorts of programs we will be writing for the next few weeks, +run-time errors are rare, so it might be a little while before you encounter one. + + +\subsection{Logic errors and semantics} +\index{semantics} +\index{logic error} +\index{error!logic} + +The third type of error is the {\bf logical} or {\bf semantic} +error. If there is a logical error in your program, it will +compile and run successfully, in the sense that the computer +will not generate any error messages, but it will not do the +right thing. It will do something else. Specifically, it will +do what you told it to do. + +The problem is that the program you wrote is not the program +you wanted to write. The meaning of the program (its semantics) +is wrong. Identifying logical errors can be tricky, since +it requires you to work backwards by looking at the output +of the program and trying to figure out what it is doing. + +\subsection{Experimental debugging} + +One of the most important skills you will acquire in this +class is debugging. Although it can be frustrating, debugging +is one of the most intellectually rich, challenging, and +interesting parts of programming. + +In some ways debugging is like detective work. You are +confronted with clues and you have to infer the processes +and events that lead to the results you see. + +Debugging is also like an experimental science. Once you have an idea +what is going wrong, you modify your program and try again. If your +hypothesis was correct, then you can predict the result of the +modification, and you take a step closer to a working program. If +your hypothesis was wrong, you have to come up with a new one. As +Sherlock Holmes pointed out, ``When you have eliminated the +impossible, whatever remains, however improbable, must be the truth.'' +(from A. Conan Doyle's {\em The Sign of Four}). + +\index{Holmes, Sherlock} +\index{Doyle, Arthur Conan} + +For some people, programming and debugging are the +same thing. That is, programming is the process of gradually +debugging a program until it does what you want. The idea +is that you should always start with a working program that +does {\em something}, and make small modifications, debugging +them as you go, so that you always have a working program. + +For example, Linux is an operating system that contains thousands of +lines of code, but it started out as a simple program Linus Torvalds +used to explore the Intel 80386 chip. According to Larry Greenfield, +``One of Linus's earlier projects was a program that would switch +between printing AAAA and BBBB. This later evolved to Linux'' +(from {\em The Linux Users' Guide} Beta Version 1). + +\index{Linux} + +In later chapters I will make more suggestions about debugging +and other programming practices. + +\section{Formal and natural languages} +\index{formal language} +\index{natural language} +\index{language!formal} +\index{language!natural} + +{\bf Natural languages} are the languages that people speak, +like English, Spanish, and French. They were not designed +by people (although people try to impose some order on them); +they evolved naturally. + +{\bf Formal languages} are languages that are designed by people for +specific applications. For example, the notation that mathematicians +use is a formal language that is particularly good at denoting +relationships among numbers and symbols. Chemists use a formal +language to represent the chemical structure of molecules. And +most importantly: + +\begin{quote} +{\bf Programming languages are formal languages that have been +designed to express computations.} +\end{quote} + +As I mentioned before, formal languages tend to have strict rules +about syntax. For example, $3+3=6$ is a syntactically correct +mathematical statement, but $3=+6\$$ is not. Also, $H_2O$ is a +syntactically correct chemical name, but $_2Zz$ is not. + +Syntax rules come in two flavors, pertaining to tokens and structure. +Tokens are the basic elements of the language, like words and numbers +and chemical elements. One of the problems with {\tt 3=+6\$} is that +{\tt \$} is not a legal token in mathematics (at least as far as I +know). Similarly, $_2Zz$ is not legal because there is no element with +the abbreviation $Zz$. + +The second type of syntax rule pertains to the structure of a +statement; that is, the way the tokens are arranged. The statement +{\tt 3=+6\$} is structurally illegal, because you can't have a plus +sign immediately after an equals sign. Similarly, molecular formulas +have to have subscripts after the element name, not before. + +When you read a sentence in English or a statement in a formal +language, you have to figure out what the structure of the sentence is +(although in a natural language you do this unconsciously). This +process is called {\bf parsing}. + +\index{parse} + +For example, when you hear the sentence, ``The other shoe fell,'' you +understand that ``the other shoe'' is the subject and ``fell'' is the +verb. Once you have parsed a sentence, you can figure out what it +means, that is, the semantics of the sentence. Assuming that you know +what a shoe is, and what it means to fall, you will understand the +general implication of this sentence. + +Although formal and natural languages have many features in +common---tokens, structure, syntax and semantics---there are many +differences. + +\index{ambiguity} +\index{redundancy} +\index{literalness} + +\begin{description} + +\item[ambiguity:] Natural languages are full of ambiguity, which +people deal with by using contextual clues and other information. +Formal languages are designed to be nearly or completely unambiguous, +which means that any statement has exactly one meaning, +regardless of context. + +\item[redundancy:] In order to make up for ambiguity and reduce +misunderstandings, natural languages employ lots of +redundancy. As a result, they are often verbose. Formal languages +are less redundant and more concise. + +\item[literalness:] Natural languages are full of idiom and +metaphor. If I say, ``The other shoe fell,'' there is probably +no shoe and nothing falling. Formal languages mean +exactly what they say. + +\end{description} + +People who grow up speaking a natural language (everyone) often have a +hard time adjusting to formal languages. In some ways the difference +between formal and natural language is like the difference between +poetry and prose, but more so: + +\index{poetry} +\index{prose} + +\begin{description} + +\item[Poetry:] Words are used for their sounds as well as for +their meaning, and the whole poem together creates an effect or +emotional response. Ambiguity is not only common but often +deliberate. + +\item[Prose:] The literal meaning of words is more important +and the structure contributes more meaning. Prose is more amenable to +analysis than poetry, but still often ambiguous. + +\item[Programs:] The meaning of a computer program is unambiguous +and literal, and can be understood entirely by analysis of the +tokens and structure. + +\end{description} + +Here are some suggestions for reading programs (and other formal +languages). First, remember that formal languages are much more dense +than natural languages, so it takes longer to read them. Also, the +structure is very important, so it is usually not a good idea to read +from top to bottom, left to right. Instead, learn to parse the +program in your head, identifying the tokens and interpreting the +structure. Finally, remember that the details matter. Little things +like spelling errors and bad punctuation, which you can get away +with in natural languages, can make a big difference in a formal +language. + +\section{The first program} +\label{hello} +\index{hello world} + +Traditionally the first program people write in a new language +is called ``Hello, World.'' because all it does is display the +words ``Hello, World.'' In C, this program looks like this: + +\begin{verbatim} + #include + #include + + /* main: generate some simple output */ + + int main(void) + { + printf("Hello, World.\n"); + return(EXIT_SUCCESS); + } + +\end{verbatim} +% +Some people judge the quality of a programming language by +the simplicity of the ``Hello, World.'' program. By this +standard, C does reasonably well. Even so, this simple program +contains several features that are hard to explain +to beginning programmers. For now, we will ignore some of them, +like the first two lines. + +\index{comment} +\index{statement!comment} + +The third line begins with {\tt /*} and ends with {\tt */}, which indicates +that it is a {\bf comment}. A comment is a bit of +English text that you can put in the middle of a program, +usually to explain what the program does. When the compiler +sees a {\tt /*}, it ignores everything from there until it finds the corresponding + {\tt */}. + +In the forth line, you notice the word {\tt main}. {\tt main} is a +special name that indicates the place in the program where execution +begins. When the program runs, it starts by executing the first +{\bf statement} in {\tt main()} and it continues, in order, until it gets +to the last statement, and then it quits. + + +\index{printf()} +\index{statement!printf} + +There is no limit to the number of statements that can be in +{\tt main()}, but the example contains only two. +The first is an {\bf output} statement, +meaning that it displays or prints a message on the screen. +The second statement tells the operating system that our program +executed successfully. + +The statement that prints things on the screen is +{\tt printf()}, and the characters between the quotation marks +will get printed. Notice the {\tt \textbackslash n} after the +last character. This is a special character called \emph{newline} that is appended at the end +of a line of text and causes the cursor to move to the next line of the display. +The next time you output something, the new text appears on the next line. +At the end of the statement +there is a semicolon ({\tt ;}), which is required at the end +of every statement. + +There are a few other things you should notice about the syntax +of this program. First, C uses curly-brackets (\{ and +\}) to group things together. +In this case, the output statement +is enclosed in curly-brackets, indicating that it is {\em inside} the +definition of {\tt main()}. Also, notice that the statement is +indented, which helps to show visually which lines are inside the +definition. + +At this point it would be a good idea to sit down in front of +a computer and compile and run this program. The details of how +to do that depend on your programming environment, this book +assumes that you know how to do it. + +As I mentioned, the C compiler is very pedantic with syntax. +If you make any errors when you type in the program, chances +are that it will not compile successfully. For example, if +you misspell {\tt stdio.h}, you might get an error message like +the following: + +\begin{verbatim} + hello_world.c:1:19: error: sdtio.h: No such file or directory +\end{verbatim} +% +There is a lot of information on this line, but it is presented +in a dense format that is not easy to interpret. A more friendly +compiler might say something like: + +\begin{quote} +``On line 1 of the source code file named hello\_world.c, you tried to +include a header file named sdtio.h. I didn't find anything +with that name, but I did find something named stdio.h. Is +that what you meant, by any chance?'' +\end{quote} + +Unfortunately, few compilers are so accommodating. The compiler +is not really very smart, and in most cases the error message +you get will be only a hint about what is wrong. It will take +some time for you to learn to interpret different compiler messages. + +Nevertheless, the compiler can be a useful tool for learning the +syntax rules of a language. Starting with a working program +(like hello\_world.c), modify it in various ways and see what happens. +If you get an error message, try to remember what the message says +and what caused it, so if you see it again in the future you +will know what it means. + + + + + +\section{Glossary} + +\begin{description} + +\item[problem-solving:] The process of formulating a problem, finding +a solution, and expressing the solution. + +\item[high-level language:] A programming language like C that +is designed to be easy for humans to read and write. + +\item[low-level language:] A programming language that is designed +to be easy for a computer to execute. Also called ``machine +language'' or ``assembly language.'' + +\item[formal language:] Any of the languages people have designed +for specific purposes, like representing mathematical ideas or +computer programs. All programming languages are formal languages. + +\item[natural language:] Any of the languages people speak that +have evolved naturally. + +\item[portability:] A property of a program that can run on more +than one kind of computer. + +\item[interpret:] To execute a program in a high-level language +by translating it one line at a time. + +\item[compile:] To translate a program in a high-level language +into a low-level language, all at once, in preparation for later +execution. + +\item[source code:] A program in a high-level language, before +being compiled. + +\item[object code:] The output of the compiler, after translating +the program. + +\item[executable:] Another name for object code that is ready +to be executed. + +\item[statement:] A part of a program that specifies an action +that will be performed when the program runs. A print statement +causes output to be displayed on the screen. + +\item[comment:] A part of a program that contains information +about the program, but that has no effect when the program runs. + +\item[algorithm:] A general process for solving a category of +problems. + +\item[bug:] An error in a program. + +\item[syntax:] The structure of a program. + +\item[semantics:] The meaning of a program. + +\item[parse:] To examine a program and analyze the syntactic structure. + +\item[syntax error:] An error in a program that makes it impossible +to parse (and therefore impossible to compile). + +%\item[exception:] An error in a program that makes it fail at +%run-time. Also called a run-time error. + +\item[logical error:] An error in a program that makes it do something +other than what the programmer intended. + +\item[debugging:] The process of finding and removing any of +the three kinds of errors. + +\index{problem-solving} +\index{high-level language} +\index{low-level language} +\index{formal language} +\index{natural language} +\index{interpret} +\index{compile} +\index{syntax} +\index{semantics} +\index{parse} +%\index{exception} +\index{error} +\index{debugging} +\index{statement} +\index{comment} + +\end{description} + +\section{Exercises} + +\input{exercises/Exercise_1_english} + diff --git a/Chapter2.tex b/Chapter2.tex new file mode 100644 index 0000000..8bc9ec8 --- /dev/null +++ b/Chapter2.tex @@ -0,0 +1,702 @@ +% LaTeX source for textbook ``How to think like a computer scientist'' +% Copyright (C) 1999 Allen B. Downey +% Copyright (C) 2009 Thomas Scheffler + +\setcounter{chapter}{1} +\chapter{Variables and types} + +\section{More output} +\index{output} +\index{statement!output} + +As I mentioned in the last chapter, you can put as many statements as +you want in {\tt main()}. For example, to output more than one line: + +\begin{verbatim} + + #include + #include + + /* main: generate some simple output */ + + int main (void) + { + printf ("Hello World.\n"); /* output one line */ + printf ("How are you?\n"); /* output another line */ + return (EXIT_SUCCESS); + } + +\end{verbatim} +% +As you can see, it is legal to put comments at the +end of a line, as well as on a line by themselves. + +\index{String} +\index{type!String} + +The phrases that appear in quotation marks are called {\bf strings}, +because they are made up of a sequence (string) of letters. Actually, +strings can contain any combination of letters, numbers, punctuation +marks, and other special characters. + +\index{newline} + +Often it is useful to display the output from multiple output +statements all on one line. You can do this by leaving out +the {\tt $\backslash$n} from the first {\tt printf}: + +\begin{verbatim} + int main (void) + { + printf ("Goodbye, "); + printf ("cruel world!\n"); + return (EXIT_SUCCESS); + } +\end{verbatim} +% +In this case the output appears on a single line as +{\tt Goodbye, cruel world!}. Notice that there is a space +between the word ``Goodbye,'' and the second quotation mark. +This space appears in the output, so it affects the behavior +of the program. + +Spaces that appear outside of quotation marks generally do +not affect the behavior of the program. For example, I +could have written: + +\begin{verbatim} + int main(void) + { + printf("Goodbye, "); + printf("cruel world!\n"); + return(EXIT_SUCCESS); + } +\end{verbatim} +% +This program would compile and run just as well as the original. +The breaks at the ends of lines (newlines) do not affect +the program's behavior either, so I could have written: + +\begin{verbatim} + int main(void){printf("Goodbye, ");printf("cruel world!\n"); + return(EXIT_SUCCESS);} +\end{verbatim} +% +That would work, too, although you have probably noticed that +the program is getting harder and harder to read. Newlines and +spaces are useful for organizing your program visually, making +it easier to read the program and locate syntax errors. + +\section{Values} +\index{value} +\index{type} + +Computer programs operate on values stored in +computer memory. +A value ---like a letter or +a number--- is one of the fundamental things that a program manipulates. +The only values we have +manipulated so far are the strings we have been outputting, like +{\tt "Hello, world."}. You (and the compiler) can identify +these string values because they are enclosed in quotation marks. +%constant values + +There are different kinds of values, including integers and characters. +It is important for the program to know exactly what kind of value +is manipulated because not all manipulations will make sense on all +values. +We therefore distinguish between different {\bf types} of values. +%Example 'a' + 'a' + +An integer is a whole number like 1 or 17. You can output +integer values in a similar way as you output strings: + +\begin{verbatim} + printf("%i\n", 17); +\end{verbatim} +% +When we look at the \texttt{printf()} statement more closely, we +notice that the value we are outputting no longer appears +inside the quotes, but behind them separated by comma. +The string is still there, but now contains a {\tt \%i} instead of +any text. +The {\tt \%i} a placeholder that tells the \texttt{printf()} command +to print an integer value. Several such placeholders exist +for different data types and formatting options of the output. +We will see the next one just now. + +A character value is a letter or digit or punctuation mark +enclosed in single quotes, like {\tt 'a'} or {\tt '5'}. +You can output character values in a similar way: + +\begin{verbatim} + printf("%c\n", '}'); +\end{verbatim} +% +This example outputs a single closing curly-bracket on a line +by itself. It uses the {\tt \%c} placeholder to signify the output of a character +value. + +It is easy to confuse different types of values, like {\tt "5"}, {\tt +'5'} and {\tt 5}, but if you pay attention to the punctuation, it +should be clear that the first is a string, the second is a character +and the third is an integer. The reason this distinction is important +should become clear soon. + +\section {Variables} +\index{variable} +\index{value} + +One of the most powerful features of a programming language is the +ability to manipulate values through the use of {\bf variables}. So far +the values that we have used in our statements where fixed to what +was written in the statement. Now we will use a variable as a named +location that stores a value. + +Just as there are different types of values (integer, character, +etc.), there are different types of variables. When you create a new +variable, you have to declare what type it is. For example, the +character type in C is called {\tt char}. The following statement +creates a new variable named {\tt fred} that has type {\tt char}. + +\begin{verbatim} + char fred; +\end{verbatim} +% +This kind of statement is called a {\bf declaration}. + +The type of a variable determines what kind of values it can +store. A {\tt char} variable can contain characters, and it should +come as no surprise that {\tt int} variables can store integers. + +Contrary to other programming languages, C does not have a +dedicated variable type for the storage of string values. We will see in +a later chapter how string values are stored in C. +%but we +%are going to skip that for now (see Chapter~\ref{strings}). + +\index{declaration} +\index{statement!declaration} + +To create an integer variable, the syntax is + +\begin{verbatim} + int bob; +\end{verbatim} +% +where {\tt bob} is the arbitrary name you choose to identify the +variable. In general, you will want to make up variable names +that indicate what you plan to do with the variable. For +example, if you saw these variable declarations: + +\begin{verbatim} + char first_letter; + char last_letter; + int hour, minute; +\end{verbatim} +% +you could probably make a good guess at what values +would be stored in them. This example +also demonstrates the syntax for declaring multiple variables +with the same type: {\tt hour} and {\tt minute} +are both integers ({\tt int} type). + +ATTENTION: The older C89 standard allows variable declarations +only at the beginning of a block of code. It is therefore necessary +to put variable declarations before any other statements, +even if the variable itself is only needed much later in your program. + +\section{Assignment} +\index{assignment} +\index{statement!assignment} + +Now that we have created some variables, we would like to +store values in them. We do that with an {\bf assignment +statement}. + +\begin{verbatim} + first_letter = 'a'; /* give first_letter the value 'a' */ + hour = 11; /* assign the value 11 to hour */ + minute = 59; /* set minute to 59 */ +\end{verbatim} +% +This example shows three assignments, and the comments show +three different ways people sometimes talk about assignment +statements. The vocabulary can be confusing here, but the +idea is straightforward: + +\begin{itemize} + +\item When you declare a variable, you create a named storage location. + +\item When you make an assignment to a variable, you give it a value. + +\end{itemize} + +A common way to represent variables on paper is to draw a box +with the name of the variable on the outside and the value +of the variable on the inside. This kind of figure is called +a {\bf state diagram} because is shows what state each +variable is in (you can think of it as the variable's ``state of +mind''). +This diagram shows the effect of the three assignment statements: + +%\vspace{0.1in} +%\centerline{\epsfig{figure=figs/assign.eps}} +%\vspace{0.1in} + +\setlength{\unitlength}{1mm} +\begin{picture}(20,17) +\put(7,12){\large \texttt{first\_letter}} +\put(46,12){\large \texttt{hour}} +\put(74,12){\large \texttt{minute}} +\put(10,0){\framebox(20,10){{\large \textsf{a}}}} +\put(40,0){\framebox(20,10){{\large \textsf{11}}}} +\put(70,0){\framebox(20,10){{\large \textsf{59}}}} +\end{picture} + +When we assign values to variables, we have to make sure that +the assigned value correspondents to the type of the variable. +In C a variable has to have the same type as the +value you assign. For example, you cannot store a string in +an {\tt int} variable. The following statement generates a compiler +warning: + +\begin{verbatim} + int hour; + hour = "Hello."; /* WRONG !! */ +\end{verbatim} +% +This rule is sometimes a source of confusion, because there are many +ways that you can convert values from one type to another, and C +sometimes converts things automatically. But for now you should +remember that as a general rule variables and values have the same +type, and we'll talk about special cases later. + +Another source of confusion is that some strings {\em look} +like integers, but they are not. For example, +the string {\tt "123"}, which is made up of the +characters {\tt 1}, {\tt 2} and {\tt 3}, is not +the same thing as the {\em number} {\tt 123}. +This assignment is illegal: + +\begin{verbatim} + minute = "59"; /* WRONG!! */ +\end{verbatim} +% +\section{Outputting variables} +\label{output variables} + +You can output the value of a variable using the same commands +we used to output simple values. + +\begin{verbatim} + + int hour, minute; + char colon; + + hour = 11; + minute = 59; + colon = ':'; + + printf ("The current time is "); + printf ("%i", hour); + printf ("%c", colon); + printf ("%i", minute); + printf ("\n"); + +\end{verbatim} +% +This program creates two integer variables named {\tt hour} and {\tt +minute}, and a character variable named {\tt colon}. It assigns +appropriate values to each of the variables and then uses a series +of output statements to generate the following: + +\begin{verbatim} + The current time is 11:59 +\end{verbatim} + +When we talk about ``outputting a variable,'' we mean outputting the +{\em value} of the variable. The name of a variable only has significance for +the programmer. The compiled program no longer contains a human readable +reference to the variable name in your program. + +The \texttt{ printf()} command is capable of outputting several variables +in a single statement. To do this, we need to put placeholders +in the so called \emph{format string}, that indicate the position where the variable value will +be put. The variables will be inserted in the order of their appearance in +the statement. It is important to observe the right order and type for the variables. + +By using a single output statement, we can make the previous program more +concise: + +\begin{verbatim} + + int hour, minute; + char colon; + + hour = 11; + minute = 59; + colon = ':'; + + printf ("The current time is %i%c%i\n", hour, colon, minute); + +\end{verbatim} +% +On one line, this program outputs a string, two integers and a character. Very impressive! + +\section{Keywords} +\index{keyword} + +A few sections ago, I said that you can make up any name you +want for your variables, but that's not quite true. There +are certain words that are reserved in C because they are +used by the compiler to parse the structure of your program, +and if you use them as variable names, it will get confused. +These words, called {\bf keywords}, include {\tt int}, +{\tt char}, {\tt void} and many more. + +\vskip 1em + +\setlength{\fboxsep}{6pt} +\begin{center} +\begin{boxedminipage}[c]{.9\linewidth} +\begin{center} +\begin{multicols}{5}[\underline{Reserved keywords in the C language}] +\begin{verbatim} +auto +break +case +char +const +continue +default +do +double +else +enum +extern +float +for +goto +if +inline +int +long +register +restrict +return +short +signed +sizeof +static +struct +switch +typedef +union +unsigned +void +volatile +while +_Bool +_Complex +_Imaginary +\end{verbatim} +\end{multicols} +\end{center} +\end{boxedminipage} +\end{center} + +\vskip 1em +The complete list of keywords is included in the C Standard, which +is the official language definition adopted by the the International +Organization for Standardization (ISO) on September 1, 1998. + +%You can download a copy electronically from +% +%\begin{verbatim} +% http://www.ansi.org/ +%\end{verbatim} +% +Rather than memorize the list, I would suggest that you +take advantage of a feature provided in many development +environments: code highlighting. As you type, different +parts of your program should appear in different colors. For +example, keywords might be blue, strings red, and other code +black. If you type a variable name and it turns blue, watch +out! You might get some strange behavior from the compiler. + +\section{Operators} +\label{operators} +\index{operator} + + +{\bf Operators} are special symbols that are used to represent +simple computations like addition and multiplication. Most +of the operators in C do exactly what you would expect them +to do, because they are common mathematical symbols. For +example, the operator for adding two integers is {\tt +}. + +The following are all legal C expressions whose meaning is +more or less obvious: + +\begin{verbatim} + 1+1 hour-1 hour*60+minute minute/60 +\end{verbatim} +% +{\bf Expressions} can contain both variables +names and values. In each case the name of the variable is +replaced with its value before the computation is performed. + +\index{expression} + +Addition, subtraction and multiplication all do what you +expect, but you might be surprised by division. For example, +the following program: + +\begin{verbatim} + + int hour, minute; + hour = 11; + minute = 59; + printf ("Number of minutes since midnight: %i\n", hour*60 + minute); + printf ("Fraction of the hour that has passed: %i\n", minute/60); + +\end{verbatim} +% +would generate the following output: + +\begin{verbatim} + Number of minutes since midnight: 719 + Fraction of the hour that has passed: 0 +\end{verbatim} +% +The first line is what we expected, but the second line is +odd. The value of the variable {\tt minute} is 59, and +59 divided by 60 is 0.98333, not 0. The reason for the +discrepancy is that C is performing {\bf integer division}. + +\index{type!int} +\index{integer division} +\index{arithmetic!integer} +\index{division!integer} +\index{operand} + +When both of the {\bf operands} are integers (operands are the things +operators operate on), the result must also be an integer, +and by definition integer division always rounds {\em down}, +even in cases like this where the next integer is so close. + +A possible alternative in this case is to calculate a percentage +rather than a fraction: + +\begin{verbatim} + printf ("Percentage of the hour that has passed: "); + printf ("%i\n", minute*100/60); +\end{verbatim} +% +The result is: + +\begin{verbatim} + Percentage of the hour that has passed: 98 +\end{verbatim} +% +Again the result is rounded down, but at least now the answer +is approximately correct. In order to get an even more accurate +answer, we could use a different type of variable, called +floating-point, that is capable of storing fractional values. +We'll get to that in the next chapter. + +\section{Order of operations} +\index{precedence} +\index{order of operations} + +When more than one operator appears in an expression the order +of evaluation depends on the rules of {\bf precedence}. A +complete explanation of precedence can get complicated, but +just to get you started: + +\begin{itemize} + +\item Multiplication and division happen before +addition and subtraction. So {\tt 2*3-1} yields 5, not 4, and {\tt +2/3-1} yields -1, not 1. +%(remember that in integer division {\tt 2/3} is 0). + +\item If the operators have the same precedence they are evaluated +from left to right. So in the expression {\tt minute*100/60}, +the multiplication happens first, yielding {\tt 5900/60}, which +in turn yields {\tt 98}. If the operations had gone from right +to left, the result would be {\tt 59*1} which is {\tt 59}, which +is wrong. + +\item Any time you want to override the rules of precedence (or +you are not sure what they are) you can use parentheses. Expressions +in parentheses are evaluated first, so {\tt 2*(3-1)} is 4. +You can also use parentheses to make an expression easier to +read, as in {\tt (minute*100)/60}, even though it doesn't +change the result. + +\end{itemize} + +\section{Operators for characters} +\index{character operator} +\index{operator!character} + +Interestingly, the same mathematical operations that work on +integers also work on characters. For example, + +\begin{verbatim} + char letter; + letter = 'a' + 1; + printf ("%c\n", letter); +\end{verbatim} +% +outputs the letter {\tt b}. Although it is syntactically legal +to multiply characters, it is almost never useful to do it. + +Earlier I said that you can only assign integer values to +integer variables and character values to character variables, +but that is not completely true. In some cases, C converts +automatically between types. For example, the following is +legal. + +\begin{verbatim} + int number; + number = 'a'; + printf ("%i\n", number); +\end{verbatim} +% +The result is 97, which is the number that is used internally +by C to represent the letter {\tt 'a'}. However, it is +generally a good idea to treat characters as characters, and +integers as integers, and only convert from one to the other +if there is a good reason. + +Automatic type conversion is an example of a common problem in designing a +programming language, which is that there is a conflict between {\bf +formalism}, which is the requirement that formal languages should have +simple rules with few exceptions, and {\bf convenience}, which is the +requirement that programming languages be easy to use in practice. + +More often than not, convenience wins, which is usually good for +expert programmers, who are spared from rigorous but unwieldy +formalism, but bad for beginning programmers, who are often baffled +by the complexity of the rules and the number of exceptions. In this +book I have tried to simplify things by emphasizing the rules and +omitting many of the exceptions. + + +\section{Composition} +\index{composition} +\index{expression} + +So far we have looked at the elements of a programming +language---variables, expressions, and statements---in +isolation, without talking about how to combine them. + +One of the most useful features of programming languages +is their ability to take small building blocks and +{\bf compose} them. For example, we know how to multiply +integers and we know how to output values; it turns out we can +do both at the same time: + +\begin{verbatim} + printf ("%i\n", 17 * 3); +\end{verbatim} +% +Actually, I shouldn't say ``at the same time,'' since in reality +the multiplication has to happen before the output, but +the point is that any expression, involving numbers, characters, +and variables, can be used inside an output statement. We've +already seen one example: + +\begin{verbatim} + printf ("%i\n", hour * 60 + minute); +\end{verbatim} +% +You can also put arbitrary expressions on the right-hand +side of an assignment statement: + +\begin{verbatim} + int percentage; + percentage = (minute * 100) / 60; +\end{verbatim} +% +This ability may not seem so impressive now, but we will see +other examples where composition makes it possible +to express complex computations neatly and concisely. + +WARNING: There are limits on where you can use certain +expressions; most notably, the left-hand side of an assignment +statement has to be a {\em variable} name, not an expression. +That's because the left side indicates the storage location +where the result will go. Expressions +do not represent storage locations, only values. So the +following is illegal: {\tt minute + 1 = hour;}. + +\section{Glossary} + +\begin{description} + +\item[variable:] A named storage location for values. All +variables have a type, which determines which values it can +store. + +\item[value:] A letter, or number, or other thing that can be +stored in a variable. + +\item[type:] The meaning of values. The types +we have seen so far are integers ({\tt int} in C) and characters ({\tt +char} in C). + +\item[keyword:] A reserved word that is used by the compiler +to parse programs. Examples we have seen include {\tt int}, +{\tt void} and {\tt char}. + +\item[statement:] A line of code that represents a command or +action. So far, the statements we have seen are declarations, +assignments, and output statements. + +\item[declaration:] A statement that creates a new variable and +determines its type. + +\item[assignment:] A statement that assigns a value to a variable. + +\item[expression:] A combination of variables, operators and +values that represents a single result value. Expressions also +have types, as determined by their operators and operands. + +\item[operator:] A special symbol that represents a simple +computation like addition or multiplication. + +\item[operand:] One of the values on which an operator operates. + +\item[precedence:] The order in which operations are evaluated. + +\item[composition:] The ability to combine simple +expressions and statements into compound statements and expressions +in order to represent complex computations concisely. + +\index{variable} +\index{value} +\index{type} +\index{keyword} +\index{statement} +\index{assignment} +\index{expression} +\index{operator} +\index{operand} +\index{composition} + +\end{description} + + +\section{Exercises} +\setcounter{exercisenum}{0} + +\input{exercises/Exercise_2_english} + + + + diff --git a/Chapter3.tex b/Chapter3.tex new file mode 100644 index 0000000..03db489 --- /dev/null +++ b/Chapter3.tex @@ -0,0 +1,735 @@ +% LaTeX source for textbook ``How to think like a computer scientist'' +% Copyright (C) 1999 Allen B. Downey +% Copyright (C) 2009 Thomas Scheffler + +\setcounter{chapter}{2} +\chapter{Function} + +\section{Floating-point} +\index{floating-point number} +\index{type!double} +\index{double (floating-point)} + +In the last chapter we had some problems dealing with numbers +that were not integers. We worked around the problem by measuring +percentages instead of fractions, but a more general solution is +to use floating-point numbers, which can represent fractions +as well as integers. In C, there are two floating-point types, +called {\tt float} and {\tt double}. In this book we will use +{\tt double}s exclusively. + +You can create floating-point variables and assign values to them +using the same syntax we used for the other types. For example: + +\begin{verbatim} + double pi; + pi = 3.14159; +\end{verbatim} +% +It is also legal to declare a variable and assign a value to it at the +same time: + +\begin{verbatim} + int x = 1; + char first_char = "a"; + double pi = 3.14159; +\end{verbatim} +% +In fact, this syntax is quite common. A combined declaration +and assignment is sometimes called an {\bf initialization}. + +\index{initialization} + +Although floating-point numbers are useful, they are +often a source of confusion because there seems to be an +overlap between integers and floating-point numbers. For +example, if you have the value {\tt 1}, is that an integer, +a floating-point number, or both? + +Strictly speaking, C distinguishes the integer value {\tt 1} +from the floating-point value {\tt 1.0}, even though they +seem to be the same number. They belong to +different types, and strictly speaking, you are not allowed +to make assignments between types. For example, the following +is illegal: + +\begin{verbatim} + int x = 1.1; +\end{verbatim} +% +Because the variable on the left is an {\tt int} +and the value on the right is a {\tt double}. But it is easy +to forget this rule, especially because there are places where C +automatically converts from one type to another. +For example, + +\begin{verbatim} + double y = 1; +\end{verbatim} +% +should technically not be legal, but C allows it by converting the +{\tt int} to a {\tt double} automatically. This is convenient for the programmer, +but it can cause problems; for example: + +\begin{verbatim} + double y = 1 / 3; +\end{verbatim} +% +You might expect the variable {\tt y} to be given the value +{\tt 0.333333}, which is a legal floating-point value, but in +fact it will get the value {\tt 0.0}. The reason is that the +expression on the right appears to be the ratio of two integers, +so C does {\em integer} division, which yields the integer +value {\tt 0}. Converted to floating-point, the result is +{\tt 0.0}. + +One way to solve this problem (once you figure out what +it is) is to make the right-hand side a floating-point +expression: + +\begin{verbatim} + double y = 1.0 / 3.0; +\end{verbatim} +% +This sets {\tt y} to {\tt 0.333333}, as expected. + +\index{arithmetic!floating-point} + +All the operations we have seen---addition, subtraction, +multiplication, and division---work on floating-point values, +although you might be interested to know that the underlying mechanism +is completely different. In fact, most processors have special +hardware just for performing floating-point operations. + +\section{Constants} +\label{sec:Constants} +\index{constants} +\index{constant values} + +In the previous section we have assigned the value 3.14159 to a +floating point variable. An important thing to remember about variables +is, that they can hold -- as their name implies -- +different values at different points in your program. +For example, we could assign +the value 3.14159 to the variable {\tt pi} now and assign +some other value to it later on: + +\begin{verbatim} + double pi = 3.14159; + ... + pi = 10.999; /* probably a logical error in your program */ +\end{verbatim} +% + +The second value is probably not what you intended when you first created the named +storage location {\tt pi} . The value for $\pi$ is constant and does not +change over time. Using the storage location {\tt pi} to hold arbitrary other values can +cause some very hard to find bugs in your program. + +C allows you to specify the static nature of storage locations through +the use of the keyword {\tt const}. It must be used in conjunction with the +required type of the constant. A value will be assigned at initialisation but can +never be changed again during the runtime of the program. + +\begin{verbatim} + const double PI = 3.14159; + printf ("Pi: %f\n", PI); + ... + PI = 10.999; /* wrong, error caught by the compiler */ +\end{verbatim} +% + +It is no longer possible to change the value for {\tt PI} once it has been initialised, but +other than this we can use it just like a variable. + +In order to visually separate constants from variables we will use +all uppercase letters in their names. + + + +%todo: typecasting überarbeiten - siehe deutsche Folien + +\section{Converting from {\tt double} to {\tt int}} +\label{rounding} +\label{typecasting} +\index{rounding} +\index{typecasting} + +As I mentioned, C converts {\tt int}s +to {\tt double}s automatically if necessary, because no +information is lost in the translation. On the other hand, +going from a {\tt double} to an {\tt int} requires rounding +off. C doesn't perform this operation automatically, in +order to make sure that you, as the programmer, are aware +of the loss of the fractional part of the number. + +The simplest way to convert a floating-point value to an integer is to +use a {\bf typecast}. Typecasting is so called because it allows you +to take a value that belongs to one type and ``cast'' it into another +type (in the sense of molding or reforming, not throwing). + +The syntax for typecasting requires the explicit specification of +the target type, set in parenthesis before the expression {\tt (Type)}. +For example: + +\begin{verbatim} + const double PI = 3.14159; + int x = (int) PI; +\end{verbatim} +% +The {\tt (int)} operator casts the value of PI into an integer, so {\tt x} gets the value +3. Converting to an integer always rounds down, even if the fraction +part is 0.99999999. + +For every type in C, there is a corresponding operator that +typecasts its argument to the appropriate type. + +\section{Math functions} +\index{math function} +\index{function!math} +\index{expression} +\index{argument} + +In mathematics, you have probably seen functions like $\sin$ and +$\log$, and you have learned to evaluate expressions like +$\sin(\pi/2)$ and $\log(1/x)$. First, you evaluate the +expression in parentheses, which is called the {\bf argument} of the +function. For example, $\pi/2$ is approximately 1.571, and $1/x$ is +0.1 (if $x$ happens to be 10). + +Then you can evaluate the function itself, either by looking it up in +a table or by performing various computations. The $\sin$ of 1.571 is +1, and the $\log$ of 0.1 is -1 (assuming that $\log$ indicates the +logarithm base 10). + +This process can be applied repeatedly to evaluate more complicated +expressions like $\log(1/\sin(\pi/2))$. First we evaluate the +argument of the innermost function, then evaluate the function, +and so on. + +C provides a set of built-in functions that includes most +of the mathematical operations you can think of. +The math functions are invoked using a syntax that is similar to +mathematical notation: + +\begin{verbatim} + double log = log (17.0); + double angle = 1.5; + double height = sin (angle); +\end{verbatim} +% +The first example sets {\tt log} to the logarithm of 17, base +$e$. There is also a function called {\tt log10} that takes +logarithms base 10. + +The second example finds the sine of the value of the variable +{\tt angle}. C assumes that the +values you use with {\tt sin} and the other trigonometric functions +({\tt cos}, {\tt tan}) are in {\em radians}. To +convert from degrees to radians, you can divide by 360 +and multiply by $2 \pi$. + +If you don't happen to know $\pi$ to 15 digits, you can +calculate it using the {\tt acos} function. The arccosine +(or inverse cosine) of -1 is $\pi$, because the cosine of +$\pi$ is -1. + +\begin{verbatim} + const double PI = acos(-1.0); + double degrees = 90; + double angle = degrees * 2 * PI / 360.0; +\end{verbatim} +% +Before you can use any of the math functions, you have to +include the math {\bf header file}. Header files contain +information the compiler needs about functions that are defined +outside your program. For example, in the ``Hello, world!'' +program we included a header file named {\tt stdio.h} using +an {\bf include} statement: + +\begin{verbatim} +#include +\end{verbatim} +% +{\tt stdio.h} contains information about input and output +(I/O) functions available in C. + +\index{header file} +\index{} +\index{} +\index{header file!stdio.h} +\index{header file!math.h} + +Similarly, the math header file contains information +about the math functions. You can include it at the beginning +of your program along with {\tt stdio.h}: + +\begin{verbatim} +#include +\end{verbatim} + +\section {Composition} +\label{composition} +\index{composition} +\index{expression} + +Just as with mathematical functions, C functions can be {\bf +composed}, meaning that you use one expression as part of another. +For example, you can use any expression as an argument to a function: + +\begin{verbatim} + double x = cos (angle + PI/2); +\end{verbatim} +% +This statement takes the value of {\tt PI}, divides it by two and +adds the result to the value of {\tt angle}. The sum is +then passed as an argument to the {\tt cos} function. + +You can also take the result of one function and pass it as +an argument to another: + +\begin{verbatim} + double x = exp (log (10.0)); +\end{verbatim} +% +This +statement finds the log base $e$ of 10 and then raises $e$ to that +power. The result gets assigned to {\tt x}; I hope you know what it +is. + +\section{Adding new functions} +\index{function!definition} +\index{main} +\index{function!main} + +So far we have only been using the functions that are built into C, +but it is also possible to add new functions. Actually, we have already +seen one function definition: {\tt main()}. The function named {\tt main()} +is special because it indicates where the execution of the program +begins, but the syntax for {\tt main()} is the same as for any other +function definition: + +\begin{verbatim} + void NAME ( LIST OF PARAMETERS ) + { + STATEMENTS + } +\end{verbatim} +% +You can make up any name you want for your function, except +that you can't call it {\tt main} or any other +C keyword. The list of +parameters specifies what information, if any, you have to +provide in order to use (or {\bf call}) the new function. + +{\tt main()} doesn't take any parameters, as indicated by +the parentheses containing the keyword {\tt (void)} in it's definition. The first couple +of functions we are going to write also have no parameters, so the +syntax looks like this: + +\begin{verbatim} + void PrintNewLine (void) + { + printf ("\n"); + } +\end{verbatim} +% +This function is named {\tt PrintNewLine()}. It contains only a single +statement, which outputs a newline character. Notice that we start +the function name with an uppercase letter. The following words of the +function name are also capitalized. We will use this convention for the naming +of functions consistently throughout the book. + +In {\tt main()} we can call this new function using syntax that +is similar to the way we call the built-in C commands: + +\begin{verbatim} + int main (void) + { + printf ("First Line.\n"); + PrintNewLine (); + printf ("Second Line.\n"); + return EXIT_SUCCESS; + } +\end{verbatim} +% +The output of this program is: +\vskip 0.5em + +\begin{verbatim} + First line. + + Second line. +\end{verbatim} +% +Notice the extra space between the two lines. What if we wanted +more space between the lines? We could call the same +function repeatedly: + +\begin{verbatim} + int main (void) + { + printf ("First Line.\n"); + NewLine (); + NewLine (); + NewLine (); + printf ("Second Line.\n"); + } +\end{verbatim} +% +Or we could write a new function, named {\tt PrintThreeLines()}, that +prints three new lines: + +\begin{verbatim} + void PrintThreeLines (void) + { + PrintNewLine (); PrintNewLine (); PrintNewLine (); + } + + int main (void) + { + printf ("First Line.\n"); + PrintThreeLines (); + printf ("Second Line.\n"); + return EXIT_SUCCESS; + } +\end{verbatim} +% +You should notice a few things about this program: + +\begin{itemize} + +\item You can call the same procedure repeatedly. In +fact, it is quite common and useful to do so. + +\item You can have one function call another function. In this +case, {\tt main()} calls {\tt PrintThreeLines()} and {\tt PrintThreeLines()} +calls {\tt PrintNewLine()}. Again, this is common and useful. + +\item In {\tt PrintThreeLines()} I wrote three statements all on the +same line, which is syntactically legal (remember that spaces +and new lines usually don't change the meaning of a program). +On the other hand, it is usually a better idea to put each +statement on a line by itself, to make your program easy to +read. I sometimes break that rule in this book to save space. + +\end{itemize} + +So far, it may not be clear why it is worth the trouble to +create all these new functions. Actually, there are a lot +of reasons, but this example only demonstrates two: + +\begin{enumerate} + +\item Creating a new function gives you an opportunity to +give a name to a group of statements. Functions can simplify a program +by hiding a complex computation behind a single command, and by using +English words in place of arcane code. Which is clearer, {\tt +PrintNewLine()} or {\tt printf("$\backslash$n")}? + +\item Creating a new function can make a program smaller by eliminating +repetitive code. For example, a short way to print nine consecutive +new lines is to call {\tt PrintThreeLines()} three times. How would you +print 27 new lines? + +\end{enumerate} + +\section {Definitions and uses} + +Pulling together all the code fragments from the previous +section, the whole program looks like this: + +\begin{verbatim} + #include + #include + + void PrintNewLine (void) + { + printf ("\n"); + } + + void PrintThreeLines (void) + { + PrintNewLine (); PrintNewLine (); PrintNewLine (); + } + + int main (void) + { + printf ("First Line.\n"); + PrintThreeLines (); + printf ("Second Line.\n"); + return EXIT_SUCCESS; + } + +\end{verbatim} + +This program contains three function definitions: {\tt PrintNewLine()}, +{\tt PrintThreeLine()}, and {\tt main()}. + +Inside the definition of {\tt main()}, there is a statement that +uses or calls {\tt PrintThreeLine()}. Similarly, {\tt PrintThreeLine()} calls +{\tt PrintNewLine()} three times. Notice that the definition of each +function appears above the place where it is used. + +This is necessary in C; the definition of a function must +appear before (above) the first use of the function. You +should try compiling this program with the functions in a +different order and see what error messages you get. + +\section {Programs with multiple functions} + +When you look at the C source code that contains several functions, it +is tempting to read it from top to bottom, but that is likely to be +confusing, because that is not the {\bf order of execution} of the +program. + +Execution always begins at the first statement of {\tt main()}, +regardless of where it is in the program (often it is at the bottom). +Statements are executed one at a time, in order, until you reach a +function call. Function calls are like a detour in the flow of +execution. Instead of going to the next statement, you go to the +first line of the called function, execute all the statements there, +and then come back and pick up again where you left off. + +That sounds simple enough, except that you have to remember that one +function can call another. Thus, while we are in the middle of {\tt +main()}, we might have to go off and execute the statements in {\tt +PrintThreeLines()}. But while we are executing {\tt PrintThreeLines()}, we get +interrupted three times to go off and execute {\tt PrintNewLine()}. + +Fortunately, C is adept at keeping track of where it is, so +each time {\tt PrintNewLine()} completes, the program picks up where it left +off in {\tt PrintThreeLine()}, and eventually gets back to {\tt main()} so the +program can terminate. + +What's the moral of this sordid tale? When you read a program, don't +read from top to bottom. Instead, follow the flow of execution. + +\section {Parameters and arguments} +\index{parameter} +\index{argument} + +Some of the built-in functions we have used have {\bf parameters}, +which are values that you provide to let the function do its +job. For example, if you want to find the sine of a number, +you have to indicate what the number is. Thus, {\tt sin()} +takes a {\tt double} value as a parameter. + +Some functions take more than one parameter, like {\tt pow()}, +which takes two {\tt doubles}, the base and the exponent. + +Notice that in each of these cases we have to specify not +only how many parameters there are, but also what type they +are. So it shouldn't surprise you that when you write a +function definition, the parameter list indicates the type of +each parameter. For example: + +\begin{verbatim} + void PrintTwice (char phil) + { + printf("%c%c\n", phil, phil); + } +\end{verbatim} +% +This function takes a single parameter, named {\tt phil}, that +has type {\tt char}. Whatever that parameter is (and at +this point we have no idea what it is), it gets printed +twice, followed by a newline. +I chose the name {\tt phil} to suggest that the name +you give a parameter is up to you, but in general you want to +choose something more illustrative than {\tt phil}. + +In order to call this function, we have to provide a {\tt char}. +For example, we might have a {\tt main()} function like this: + +\begin{verbatim} + int main (void) + { + PrintTwice ('a'); + return EXIT_SUCCESS; + } +\end{verbatim} +% +The {\tt char} value you provide is called an {\bf argument}, and we +say that the argument is {\bf passed} to the function. In this +case the value {\tt 'a'} is passed as an argument +to {\tt PrintTwice()} where it will get printed twice. + +Alternatively, if we had a {\tt char} variable, we could +use it as an argument instead: + +\begin{verbatim} + int main () + { + char argument = 'b'; + PrintTwice (argument); + return EXIT_SUCCESS; + } +\end{verbatim} +% +Notice something very important here: the name of the variable we pass +as an argument ({\tt argument}) has nothing to do with the name of the +parameter ({\tt phil}). Let me say that again: + +\begin{quote} + +{\bf The name of the variable we pass as an argument has nothing to do +with the name of the parameter.} + +\end{quote} + +They can be the same or they can be different, but it is important +to realize that they are not the same thing, except that they happen +to have the same value (in this case the character {\tt 'b'}). + +The value you provide as an argument must have the same type as +the parameter of the function you call. This rule is +important, but it is sometimes confusing because C sometimes +converts arguments from one type to another automatically. For +now you should learn the general rule, and we will deal with +exceptions later. + +\section {Parameters and variables are local} + +Parameters and +variables only exist inside their own functions. Within the +confines of {\tt main()}, there is no such thing as {\tt phil}. +If you try to use it, the compiler will complain. Similarly, +inside {\tt PrintTwice()} there is no such thing as {\tt argument}. + +Variables like this are said to be {\bf local}. In order to +keep track of parameters and local variables, it is useful to +draw a {\bf stack diagram}. Like state diagrams, stack diagrams +show the value of each variable, but the variables are contained +in larger boxes that indicate which function they belong to. + +For example, the stack diagram for {\tt PrintTwice()} looks +like this: + +\vspace{0.1in} +\centerline{\epsfig{figure=figs/stack.pdf,width=6cm}} +\vspace{0.1in} +% +Whenever a function is called, it creates a new {\bf instance} +of that function. Each instance of a function contains the +parameters and local variables for that function. In the +diagram an instance of a function is represented by a box +with the name of the function on the outside and the variables +and parameters inside. + +In the example, {\tt main()} has one local variable, {\tt argument}, and +no parameters. {\tt PrintTwice()} has no local variables and one +parameter, named {\tt phil}. + +\section {Functions with multiple parameters} +\index{parameter!multiple} +\index{function!multiple parameter} +%\index{class!Time} + +The syntax for declaring and invoking functions with multiple +parameters is a common source of errors. First, remember +that you have to declare the type of every parameter. For +example + +\begin{verbatim} + void PrintTime (int hour, int minute) + { + printf ("%i", hour); + printf (":"); + printf ("%i", minute); + } +\end{verbatim} +% +It might be tempting to write {\tt (int hour, minute)}, but +that format is only legal for variable declarations, not +for parameters. + +Another common source of confusion is that you do not have +to declare the types of arguments. The following is wrong! + +\begin{verbatim} + int hour = 11; + int minute = 59; + PrintTime (int hour, int minute); /* WRONG! */ +\end{verbatim} +% +In this case, the compiler can tell the type of {\tt hour} +and {\tt minute} by looking at their declarations. It is +unnecessary and illegal to include the type when you pass them +as arguments. The correct +syntax is {\tt PrintTime (hour, minute);}. + +\section {Functions with results} +\index{fruitful function} +\index{function!fruitful} + +You might have noticed by now that some of the functions we are using, +like the math functions, yield results. Other functions, +like {\tt PrintNewLine}, perform an action but +don't return a value. That raises some questions: + +\begin{itemize} + +\item What happens if you call a function and you don't +do anything with the result (i.e. you don't assign it to +a variable or use it as part of a larger expression)? + +\item What happens if you use a function without a result as part +of an expression, like {\tt PrintNewLine() + 7}? + +\item Can we write functions that yield results, or are we +stuck with things like {\tt PrintNewLine()} and {\tt PrintTwice()}? + +\end{itemize} + +The answer to the third question is ``yes, you can write functions that +return values,'' and we'll do it in a couple of chapters. I will +leave it up to you to answer the other two questions by trying them +out. Any time you have a question about what is legal or +illegal in C, a good way to find out is to ask the compiler. + +\section{Glossary} + +\begin{description} + +\item[constant:] A named storage location similar to a variable, that can not be changed +once it has been initialised. + +\item[floating-point:] A type of variable (or value) that can contain +fractions as well as integers. There are a few floating-point types +in C; the one we use in this book is {\tt double}. + +\item[initialization:] A statement that declares a new variable +and assigns a value to it at the same time. + +\item[function:] A named sequence of statements that performs some +useful function. Functions may or may not take parameters, and may +or may not produce a result. + +\item[parameter:] A piece of information you provide +in order to call a function. Parameters are like variables in +the sense that they contain values and have types. + +\item[argument:] A value that you provide when you call a +function. This value must have the same type as the corresponding +parameter. + +\item[call:] Cause a function to be executed. + +\index{floating-point} +\index{function} +\index{parameter} +\index{argument} +\index{call} +\index{initialization} + +\end{description} + + +\section{Exercises} +\setcounter{exercisenum}{0} + + +\input{exercises/Exercise_3_english} + + diff --git a/Chapter4.tex b/Chapter4.tex new file mode 100644 index 0000000..8c9f441 --- /dev/null +++ b/Chapter4.tex @@ -0,0 +1,481 @@ +% LaTeX source for textbook ``How to think like a computer scientist'' +% Copyright (C) 1999 Allen B. Downey +% Copyright (C) 2009 Thomas Scheffler + + +\chapter{Conditionals and recursion} +\label{condrecursion} + + +\section{Conditional execution} +\index{conditional} +\index{statement!conditional} + +In order to write useful programs, we almost always need the ability +to check certain conditions and change the behavior of the program +accordingly. {\bf Conditional statements} give us this ability. The +simplest form is the {\tt if} statement: + +\begin{verbatim} + if (x > 0) + { + printf ("x is positive\n"); + } +\end{verbatim} +% +The expression in parentheses is called the condition. +If it is true, then the statements in brackets get executed. +If the condition is not true, nothing happens. + +\index{operator!comparison} +\index{comparison!operator} + +The condition can contain any of the {\bf comparison operators}: + +\begin{verbatim} + x == y /* x equals y */ + x != y /* x is not equal to y */ + x > y /* x is greater than y */ + x < y /* x is less than y */ + x >= y /* x is greater than or equal to y */ + x <= y /* x is less than or equal to y */ +\end{verbatim} +% +Although these operations are probably familiar to you, the +syntax C uses is a little different from mathematical +symbols like $=$, $\neq$ and $\le$. A common error is +to use a single {\tt =} instead of a double {\tt ==}. Remember +that {\tt =} is the assignment operator, and {\tt ==} is +a comparison operator. Also, there is no such thing as +{\tt =<} or {\tt =>}. + +The two sides of a condition operator have to be the same +type. You can only compare {\tt ints} to {\tt ints} and +{\tt doubles} to {\tt doubles}. Unfortunately, at this +point you can't compare strings at all! There is +a way to compare strings, but we won't get to it for a couple +of chapters. + +\section{The modulus operator} +\index{modulus} +\index{operator!modulus} + +The modulus operator works on integers (and integer expressions) +and yields the {\em remainder} when the first operand is divided +by the second. In C, the modulus operator is a percent sign, +{\tt \%}. The syntax is exactly the same as for other operators: + +\begin{verbatim} + int quotient = 7 / 3; + int remainder = 7 % 3; +\end{verbatim} +% +The first operator, integer division, yields 2. The second +operator yields 1. Thus, 7 divided by 3 is 2 with 1 left over. + +The modulus operator turns out to be surprisingly useful. For +example, you can check whether one number is divisible by +another: if {\tt x \% y} is zero, then {\tt x} is divisible +by {\tt y}. + +Also, you can use the modulus operator to extract the rightmost +digit or digits from a number. For example, {\tt x \% 10} yields +the rightmost digit of {\tt x} (in base 10). Similarly +{\tt x \% 100} yields the last two digits. + +\section {Alternative execution} +\label{alternative} +\index{conditional!alternative} + +A second form of conditional execution is alternative execution, +in which there are two possibilities, and the condition determines +which one gets executed. The syntax looks like: + +\begin{verbatim} + if (x%2 == 0) + { + printf ("x is even\n"); + } + else + { + printf ("x is odd\n"); + } +\end{verbatim} +% +If the remainder when {\tt x} is divided by 2 is zero, then +we know that {\tt x} is even, and this code displays a message +to that effect. If the condition is false, the second +set of statements is executed. Since the condition must +be true or false, exactly one of the alternatives will be +executed. + +As an aside, if you think you might want to check the parity +(evenness or oddness) of numbers often, you might want to +``wrap'' this code up in a function, as follows: + +\begin{verbatim} + void PrintParity (int x) + { + if (x%2 == 0) + { + printf ("x is even\n"); + } + else + { + printf ("x is odd\n"); + } + } +\end{verbatim} +% +Now you have a function named {\tt PrintParity()} that will display +an appropriate message for any integer you care to provide. +In {\tt main()} you would call this function as follows: + +\begin{verbatim} + PrintParity (17); +\end{verbatim} +% +Always remember that when you {\em call} a function, you do +not have to declare the types of the arguments you provide. +C can figure out what type they are. You should resist the +temptation to write things like: + +\begin{verbatim} + int number = 17; + PrintParity (int number); /* WRONG!!! */ +\end{verbatim} + +\section {Chained conditionals} +\index{conditional!chained} + +Sometimes you want to check for a number of related conditions +and choose one of several actions. One way to do this is by +{\bf chaining} a series of {\tt if}s and {\tt else}s: + +\begin{verbatim} + if (x > 0) + { + printf ("x is positive\n"); + } + else if (x < 0) + { + printf ("x is negative\n"); + } + else + { + printf ("x is zero\n"); + } +\end{verbatim} +% +These chains can be as long as you want, although they can +be difficult to read if they get out of hand. One way to +make them easier to read is to use standard indentation, +as demonstrated in these examples. If you keep all the +statements and squiggly-braces lined up, you are less +likely to make syntax errors and you can find them more +quickly if you do. + +\section{Nested conditionals} +\index{conditional!nested} + +In addition to chaining, you can also nest one conditional +within another. We could have written the previous example +as: + +\begin{verbatim} + if (x == 0) + { + printf ("x is zero\n"); + } + else + { + if (x > 0) + { + printf ("x is positive\n"); + } + else + { + printf ("x is negative\n"); + } + } +\end{verbatim} +% +There is now an outer conditional that contains two branches. The +first branch contains a simple output statement, but the second +branch contains another {\tt if} statement, which has two branches +of its own. Fortunately, those two branches are both output +statements, although they could have been conditional statements as +well. + +Notice again that indentation helps make the structure +apparent, but nevertheless, nested conditionals get difficult to read +very quickly. In general, it is a good idea to avoid them when you +can. + +\index{nested structure} + +On the other hand, this kind of {\bf nested structure} is common, and +we will see it again, so you better get used to it. + +\section{The {\tt return} statement} +\index{return} +\index{statement!return} + +The {\tt return} statement allows you to terminate the execution +of a function before you reach the end. One reason to use it +is if you detect an error condition: + +\begin{verbatim} + #include + + void PrintLogarithm (double x) + { + if (x <= 0.0) + { + printf ("Positive numbers only, please.\n"); + return; + } + + double result = log (x); + printf ("The log of x is %f\n", result); + } +\end{verbatim} +% +This defines a function named {\tt PrintLogarithm()} that takes +a {\tt double} named {\tt x} as a parameter. The first thing +it does is check whether {\tt x} is less than or equal to +zero, in which case it displays an error message and then uses +{\tt return} to exit the function. The flow of execution +immediately returns to the caller and the remaining lines of +the function are not executed. + +I used a floating-point value on the right side of the condition +because there is a floating-point variable on the left. + +Remember that any time you want to use one a function from the math +library, you have to include the header file {\tt math.h}. + +\section{Recursion} +\label{recursion} +\index{recursion} + +I mentioned in the last chapter that it is legal for one function to +call another, and we have seen several examples of that. I neglected +to mention that it is also legal for a function to call itself. It +may not be obvious why that is a good thing, but it turns out to be +one of the most magical and interesting things a program can do. + +For example, look at the following function: + +\begin{verbatim} + void Countdown (int n) + { + if (n == 0) + { + printf ("Blastoff!"); + } + else + { + printf ("%i", n); + Countdown (n-1); + } + } +\end{verbatim} +% +The name of the function is {\tt Countdown()} and it takes a single +integer as a parameter. If the parameter is zero, it outputs +the word ``Blastoff.'' Otherwise, it outputs the parameter and +then calls a function named {\tt Countdown()}---itself---passing +{\tt n-1} as an argument. + +What happens if we call this function like this: + +\begin{verbatim} + int main (void) + { + Countdown (3); + return EXIT_SUCCESS; + } +\end{verbatim} +% +The execution of {\tt Countdown()} begins with {\tt n=3}, and +since {\tt n} is not zero, it outputs the value 3, and then +calls itself... + +\begin{quote} +The execution of {\tt Countdown()} begins with {\tt n=2}, and +since {\tt n} is not zero, it outputs the value 2, and then +calls itself... + +\begin{quote} +The execution of {\tt Countdown()} begins with {\tt n=1}, and +since {\tt n} is not zero, it outputs the value 1, and then +calls itself... + +\begin{quote} +The execution of {\tt Countdown()} begins with {\tt n=0}, and +since {\tt n} is zero, it outputs the word ``Blastoff!'' +and then returns. +\end{quote} + +The Countdown that got {\tt n=1} returns. + +\end{quote} + +The Countdown that got {\tt n=2} returns. + +\end{quote} + +The Countdown that got {\tt n=3} returns. + +\noindent And then you're back in {\tt main()} (what a trip). So the +total output looks like: + +\begin{verbatim} + 3 + 2 + 1 + Blastoff! +\end{verbatim} +% +As a second example, let's look again at the functions +{\tt PrintNewLine()} and {\tt PrintThreeLines()}. + +\begin{verbatim} + void PrintNewLine () + { + printf ("\n"); + } + + void PrintThreeLines () + { + PrintNewLine (); PrintNewLine (); PrintNewLine (); + } +\end{verbatim} +% +Although these work, they would not be much help if I wanted +to output 2 newlines, or 106. A better alternative would be + +\begin{verbatim} + void PrintLines (int n) + { + if (n > 0) + { + printf ("\n"); + PrintLines (n-1); + } + } +\end{verbatim} +% +This program is similar to {\tt Countdown}; as long as {\tt n} is +greater than zero, it outputs one newline, and then calls itself to +output {\tt n-1} additional newlines. Thus, the total number of +newlines is {\tt 1 + (n-1)}, which usually comes out to roughly {\tt +n}. + +\index{recursive} +\index{newline} + +The process of a function calling itself is called {\bf recursion}, and +such functions are said to be {\bf recursive}. + +\section {Infinite recursion} + +In the examples in the previous section, notice that each time the +functions get called recursively, the argument gets smaller by one, so +eventually it gets to zero. When the argument is zero, the function +returns immediately, {\em without making any recursive calls}. +This case---when the function completes without making a recursive +call---is called the {\bf base case}. + +If a recursion never reaches a base case, it will go on making recursive +calls forever and the program will never terminate. This is known as +{\bf infinite recursion}, and it is generally not considered a good +idea. + +\index{recursion!infinite} +\index{infinite recursion} +\index{run-time error} + +In most programming environments, a program with an infinite +recursion will not really run forever. Eventually, something +will break and the program will report an error. This is the +first example we have seen of a run-time error (an error that +does not appear until you run the program). + +You should write a small program that recurses forever and run +it to see what happens. + +\section {Stack diagrams for recursive functions} +\index{stack} +\index{stack diagram} +\index{diagram!state} +\index{diagram!stack} + +In the previous chapter we used a stack diagram to represent the +state of a program during a function call. The same kind +of diagram can make it easier to interpret a recursive function. + +Remember that every time a function gets called it creates +a new instance that contains +the function's local variables and parameters. + +This figure shows a stack diagram for Countdown, called +with {\tt n = 3}: + +\vspace{0.1in} +\centerline{\epsfig{figure=figs/stack2.pdf,width=6cm}} +\vspace{0.1in} +% +There is one instance of {\tt main()} and four instances of +{\tt Countdown()}, each with a different value for the parameter +{\tt n}. The bottom of the stack, {\tt Countdown()} with {\tt n=0} +is the base case. It does not make a recursive call, so there +are no more instances of {\tt Countdown()}. + +The instance of {\tt main()} is empty because {\tt main()} does not +have any parameters or local variables. As an exercise, draw a +stack diagram for {\tt PrintLines()}, invoked with the parameter {\tt n=4}. + + +\section{Glossary} + +\begin{description} + +\item[modulus:] An operator that works on integers and yields +the remainder when one number is divided by another. In C +it is denoted with a percent sign ({\tt \%}). + +\item[conditional:] A block of statements that may or may not +be executed depending on some condition. + +\item[chaining:] A way of joining several conditional statements +in sequence. + +\item[nesting:] Putting a conditional statement inside one or both +branches of another conditional statement. + +\item[recursion:] The process of calling the same function you +are currently executing. + +\item[infinite recursion:] A function that calls itself +recursively without every reaching the base case. Eventually +an infinite recursion will cause a run-time error. + +\index{modulus} +\index{conditional} +\index{conditional!chained} +\index{conditional!nested} +\index{recursion} +\index{recursion!infinite} +\index{infinite recursion} + +\end{description} + + +\section{Exercises} +\setcounter{exercisenum}{0} + + +\input{exercises/Exercise_4_english} + diff --git a/Chapter5.tex b/Chapter5.tex new file mode 100644 index 0000000..28417c9 --- /dev/null +++ b/Chapter5.tex @@ -0,0 +1,935 @@ +% LaTeX source for textbook ``How to think like a computer scientist'' +% Copyright (C) 1999 Allen B. Downey +% Copyright (C) 2009 Thomas Scheffler + + +\chapter{Fruitful functions} + +\section{Return values} +\index{return} +\index{statement!return} +\index{function!fruitful} +\index{fruitful function} +\index{return value} +\index{void} +\index{function!void} + +Some of the built-in functions we have used, like the math +functions, have produced results. That is, the effect of +calling the function is to generate a new value, which we +usually assign to a variable or use as part of an expression. +For example: + +\index{math function!exp()} +\index{math function!sin()} + +\begin{verbatim} + double e = exp (1.0); + double height = radius * sin (angle); +\end{verbatim} +% +But so far all the functions we have written have been {\bf void} +functions; that is, functions that return no value. When you call +a void function, it is typically on a line by itself, with +no assignment: + +\begin{verbatim} + PrintLines (3); + Countdown (n-1); +\end{verbatim} +% +In this chapter, we are going to write functions that return things, +which I will refer to as {\bf fruitful} functions, for want of a +better name. The first example is {\tt area}, which takes a {\tt +double} as a parameter, and returns the area of a circle with the +given radius: + +\index{math function!acos()} +\index{pi} + +\begin{verbatim} + double Area (double radius) + { + double pi = acos (-1.0); + double area = pi * radius * radius; + return area; + } +\end{verbatim} +% +The first thing you should notice is that the beginning of the +function definition is different. Instead of {\tt void}, which +indicates a void function, we see {\tt double}, which indicates that +the return value from this function will have type {\tt double}. + +Also, notice that the last line is an alternate form of the +{\tt return} statement that includes a return value. This +statement means, ``return immediately from this function and +use the following expression as a return value.'' The +expression you provide can be arbitrarily complicated, +so we could have written this function more concisely: + +\begin{verbatim} + double Area (double radius) + { + return acos(-1.0) * radius * radius; + } +\end{verbatim} +% +On the other hand, {\bf temporary} variables like {\tt area} often +make debugging easier. In either case, the type of the expression in +the {\tt return} statement must match the return type of the function. +In other words, when you declare that the return type is {\tt double}, +you are making a promise that this function will eventually +produce a {\tt double}. If you try to {\tt return} with no +expression, or an expression with the wrong type, the compiler will +take you to task. + +\index{temporary variable} +\index{variable!temporary} + +Sometimes it is useful to have multiple return +statements, one in each branch of a conditional: + +\begin{verbatim} + double AbsoluteValue (double x) + { + if (x < 0) + { + return -x; + } + else + { + return x; + } + } +\end{verbatim} +% +Since these returns statements are in an alternative conditional, only +one will be executed. Although it is legal to have more than one +{\tt return} statement in a function, you should keep in mind that as soon +as one is executed, the function terminates without executing any +subsequent statements. + +Code that appears after a {\tt return} statement, or any place else +where it can never be executed, is called {\bf dead code}. Some +compilers warn you if part of your code is dead. + +\index{dead code} + +If you put return statements inside a conditional, then +you have to guarantee that {\em every possible path} through +the program hits a return statement. For example: + +\begin{verbatim} + double AbsoluteValue (double x) + { + if (x < 0) + { + return -x; + } + else if (x > 0) + { + return x; + } /* WRONG!! */ +} +\end{verbatim} +% +This program is not correct because if {\tt x} happens to be 0, then +neither condition will be true and the function will end without hitting +a return statement. Unfortunately, many C compilers do not catch +this error. As a result, the program may compile and run, but the +return value when {\tt x==0} could be anything, and will probably +be different in different environments. + +\index{absolute value} +\index{error!compile-time} +\index{compile-time error} + +By now you are probably sick of seeing compiler errors, but as you +gain more experience, you will realize that the only thing worse +than getting a compiler error is {\em not} getting a compiler error +when your program is wrong. + +Here's the kind of thing that's likely to happen: you test {\tt +AbsoluteValue()} with several values of {\tt x} and it seems to work +correctly. Then you give your program to someone else and they run it +in another environment. It fails in some mysterious way, and it +takes days of debugging to discover that the problem is an +incorrect implementation of {\tt AbsoluteValue()}. If only the +compiler had warned you! + +\index{compile-time error} +\index{error!compile-time} +\index{debugging} + +From now on, if the compiler points out an error in your program, you +should not blame the compiler. Rather, you should thank the compiler +for finding your error and sparing you days of debugging. Some +compilers have an option that tells them to be extra strict and report +all the errors they can find. You should turn this option on all the +time. + +\index{math function!fabs()} + +As an aside, you should know that there is a function in the +math library called {\tt fabs()} that calculates the absolute +value of a {\tt double} -- correctly. + +\section{Program development} +\label{distance} +\index{program development} + +At this point you should be able to look at complete C functions +and tell what they do. But it may not be clear yet how to go +about writing them. I am going to suggest one technique that +I call {\bf incremental development}. + +\index{incremental development} +\index{program development} + +As an example, imagine you want to find the distance between two +points, given by the coordinates $(x_1, y_1)$ and $(x_2, y_2)$. By +the usual definition, + +\begin{equation} +distance = \sqrt{(x_2 - x_1)^2 + (y_2 - y_1)^2} +\end{equation} +% +The first step is to consider what a {\tt Distance} function +should look like in C. In other words, what are the inputs +(parameters) and what is the output (return value). + +In this case, the two points are the parameters, and it is natural to +represent them using four {\tt double}s. The return value is the +distance, which will have type {\tt double}. + +Already we can write an outline of the function: + +\begin{verbatim} + double Distance (double x1, double y1, double x2, double y2) + { + return 0.0; + } +\end{verbatim} +% +The {\tt return} statement is a placekeeper so that the function will +compile and return something, even though it is not the right answer. +At this stage the function doesn't do anything useful, but it is +worthwhile to try compiling it so we can identify any syntax errors +before we make it more complicated. + +In order to test the new function, we have to call it with +sample values. Somewhere in {\tt main()} I would add: + +\begin{verbatim} + double dist = Distance (1.0, 2.0, 4.0, 6.0); + printf ("%f\n" dist); +\end{verbatim} +% +I chose these values so that the horizontal +distance is 3 and the vertical distance is 4; that way, +the result will be 5 (the hypotenuse of a 3-4-5 triangle). +When you are testing a function, it is useful to know the right +answer. + +Once we have checked the syntax of the function definition, we +can start adding lines of code one at a time. After each +incremental change, we recompile and run the program. That +way, at any point we know exactly where the error must be---in +the last line we added. + +The next step in the computation is to find the differences +$x_2 - x_1$ and $y_2 - y_1$. I will store those values in +temporary variables named {\tt dx} and {\tt dy}. + +\begin{verbatim} + double Distance (double x1, double y1, double x2, double y2) + { + double dx = x2 - x1; + double dy = y2 - y1; + printf ("dx is %f\n", dx); + printf ("dy is %f\n", dy; + return 0.0; + } +\end{verbatim} +% +I added output statements that will let me check the intermediate +values before proceeding. As I mentioned, I already know that they +should be 3.0 and 4.0. + +\index{scaffolding} + +When the function is finished I will remove the output statements. Code +like that is called {\bf scaffolding}, because it is helpful for +building the program, but it is not part of the final product. +Sometimes it is a good idea to keep the scaffolding around, but +comment it out, just in case you need it later. + +The next step in the development is to square {\tt dx} and {\tt dy}. +We could use the {\tt pow()} function, but it is simpler and +faster to just multiply each term by itself. + +\begin{verbatim} + double Distance (double x1, double y1, double x2, double y2) + { + double dx = x2 - x1; + double dy = y2 - y1; + double dsquared = dx*dx + dy*dy; + printf ("d_squared is %f\n", dsquared); + return 0.0; + } +\end{verbatim} +% +Again, I would compile and run the program at this stage +and check the intermediate value (which should be 25.0). + +Finally, we can use the {\tt sqrt()} function to compute and +return the result. + +\begin{verbatim} + double Distance (double x1, double y1, double x2, double y2) + { + double dx = x2 - x1; + double dy = y2 - y1; + double dsquared = dx*dx + dy*dy; + double result = sqrt (dsquared); + return result; + } +\end{verbatim} +% +Then in {\tt main()}, we should output and check the value of the result. + +As you gain more experience programming, you might find yourself +writing and debugging more than one line at a time. Nevertheless, +this incremental development process can save you a lot of +debugging time. + +The key aspects of the process are: + +\begin{itemize} + +\item Start with a working program and make small, incremental +changes. At any point, if there is an error, you will know +exactly where it is. + +\item Use temporary variables to hold intermediate values so +you can output and check them. + +\item Once the program is working, you might want to remove +some of the scaffolding or consolidate multiple statements into +compound expressions, but only if it does not make the program +difficult to read. + +\end{itemize} + +\section{Composition} +\index{composition} + +As you should expect by now, once you define a new function, +you can use it as part of an expression, and you can build +new functions using existing functions. For example, what if someone +gave you two points, the center of the circle and a point on +the perimeter, and asked for the area of the circle? + +Let's say the center point is stored in the variables {\tt xc} +and {\tt yc}, and the perimeter point is in {\tt xp} and +{\tt yp}. The first step is to find the radius of the circle, which +is the distance between the two points. Fortunately, we have +a function, {\tt Distance()}, that does that. + +\begin{verbatim} + double radius = Distance (xc, yc, xp, yp); +\end{verbatim} +% +The second step is to find the area of a circle with that +radius, and return it. + +\begin{verbatim} + double result = Area (radius); + return result; +\end{verbatim} +% +Wrapping that all up in a function, we get: + +\begin{verbatim} + double AreaFromPoints (double xc, double yc, double xp, double yp) + { + double radius = Distance (xc, yc, xp, yp); + double result = Area (radius); + return result; + } +\end{verbatim} +% + + +The temporary variables {\tt radius} and {\tt area} are +useful for development and debugging, but once the program is +working we can make it more concise by composing +the function calls: + +\begin{verbatim} + double AreaFromPoints (double xc, double yc, double xp, double yp) + { + return Area (Distance (xc, yc, xp, yp)); + } +\end{verbatim} + + +\section{Boolean values} +\index{boolean} +\index{value!boolean} + +The types we have seen so far can hold very large values. There are a lot +of integers in the world, and even more floating-point numbers. +By comparison, the set of characters is pretty small. Well, many computing +languages implement an even more fundamental type that is even smaller. It is called +{\bf \_Bool}, and the only values in it are {\tt true} and {\tt false}. + +Unfortunately, earlier versions of the C standard did not implement boolean as +a separate type, but instead used the integer values 0 and 1 to represent +truth values. By convention 0 represents {\tt false} and 1 represents {\tt true}. +Strictly speaking C interprets any integer value different from 0 as true. This +can be a source of error if you are testing a value to be true by comparing it with {\tt 1}. + +% + +Without thinking about it, we have been using boolean values in the +last of chapter. The condition inside an {\tt if} +statement is a boolean expression. +Also, the result of a comparison operator is a boolean value. +For example: + +\begin{verbatim} + if (x == 5) + { + /* do something*/ + } +\end{verbatim} +% +The operator {\tt ==} compares two integers and produces a +boolean value. + +\index{operator!comparison} +\index{comparison operator} + +Pre C99 has no keywords for the expression of {\tt true} or {\tt false}. +A lot of programs instead are +using C preprocessor definitions anywhere a boolean expression is called for. +For example, + +\begin{verbatim} + #define FALSE 0 + #define TRUE 1 + ... + if (TRUE) + { + /* will be always executed */ + } +\end{verbatim} +% +%todo: Loop? +is a standard idiom for a loop that should run forever (or +until it reaches a {\tt return} or {\tt break} statement). + +\section{Boolean variables} +\index{type!{\tt bool}} + +Since boolean values are not supported directly in C, we can not declare +variables of the type boolean. +Instead, programmers typically use the {\tt short} datatype in combination with +preprocessor definitions to store truth values. + +\begin{verbatim} + #define FALSE 0 + #define TRUE 1 + ... + short fred; + fred = TRUE; + short testResult = FALSE; +\end{verbatim} +% +The first line is a simple variable declaration; +the second line is an assignment, and the third line is a +combination of a declaration and as assignment, +called an initialization. + +\index{initialization} +\index{statement!initialization} + +As I mentioned, the result of a comparison operator is a boolean, +so you can store it in a variable + +\begin{verbatim} + short evenFlag = (n%2 == 0); /* true if n is even */ + short positiveFlag = (x > 0); /* true if x is positive */ +\end{verbatim} +% +and then use it as part of a conditional statement later + +\begin{verbatim} + if (evenFlag) + { + printf("n was even when I checked it"); + } +\end{verbatim} +% +A variable used in this way is called a {\bf flag}, +since it flags the presence or absence of some condition. + +\index{flag} + +\section{Logical operators} +\index{logical operator} +\index{operator!logical} + +There are three {\bf logical operators} in C: AND, OR and NOT, +which are denoted by the symbols {\tt \&\&}, {\tt ||} and +{\tt !}. The semantics (meaning) of these operators is similar +to their meaning in English. For example {\tt x > 0 \&\& x < 10} +is true only if {\tt x} is greater than zero AND less than 10. + +\index{semantics} + +{\tt evenFlag || n\%3 == 0} is true if {\em either} of +the conditions is true, that is, if {\tt evenFlag} is true OR the +number is divisible by 3. + +Finally, the NOT operator has the effect of negating or +inverting a bool expression, so {\tt !evenFlag} is true +if {\tt evenFlag} is false; that is, if the number is odd. + +\index{nested structure} + +Logical operators often provide a way to simplify nested +conditional statements. For example, how would you write +the following code using a single conditional? + +\begin{verbatim} + if (x > 0) + { + if (x < 10) + { + printf ("x is a positive single digit.\n"); + } + } +\end{verbatim} + +\section{Bool functions} +\label{bool} +\index{bool} +\index{function!bool} + +It is sometimes appropriate for functions to return {\tt boolean} values just +like any other return type. This is +is especially convenient for hiding complicated tests inside +functions. For example: + +\begin{verbatim} + int IsSingleDigit (int x) + { + if (x >= 0 && x < 10) + { + return TRUE; + } + else + { + return FALSE; + } + } +\end{verbatim} +% +The name of this function is {\tt IsSingleDigit()}. It is common +to give such test functions names that sound like yes/no questions. +The return type is {\tt int}, which means that again we need +to follow the agreement that 0 represents {\tt false} and 1 +represents {\tt true}. Every return +statement has to follow this convention, again, we are using +preprocessor definitions. + +The code itself is straightforward, although it is a bit longer than +it needs to be. Remember that the expression {\tt x >= 0 \&\& x < 10} +is evaluated to a {\tt boolean} value, so there is nothing wrong with returning it +directly, and avoiding the {\tt if} statement altogether: + +\begin{verbatim} + int IsSingleDigit (int x) + { + return (x >= 0 && x < 10); + } +\end{verbatim} +% +In {\tt main()} you can call this function in the usual ways: + +\begin{verbatim} + printf("%i\n", IsSingleDigit (2)); + short bigFlag = !IsSingleDigit (17); +\end{verbatim} +% +The first line outputs the value {\tt true} because 2 is a +single-digit number. Unfortunately, when C outputs {\tt boolean} values, it +does not display the words {\tt TRUE} and {\tt FALSE}, but rather the +integers {\tt 1} and {\tt 0}. +%\footnote{There is a way to fix that +%using the {\tt boolalpha} flag, but it is too hideous to mention.} + +The second line assigns the value {\tt true} to {\tt bigFlag} +only if 17 is {\em not} a positive single-digit number. + +The most common use of boolean functions is inside conditional +statements + +\begin{verbatim} + if (IsSingleDigit (x)) + { + printf("x is little\n"); + } + else + { + printf("x is big\n"); + } +\end{verbatim} + +\section {Returning from {\tt main()}} + +Now that we know functions that return values, we can look more closely at the +return value of the {\tt main()} function. +It's supposed to return an integer: + +\begin{verbatim} + int main (void) +\end{verbatim} + +The usual return value from {\tt main()} is 0, which indicates that +the program succeeded at whatever it was supposed to to. If something +goes wrong, it is common to return -1, or some other value that +indicates what kind of error occurred. + + +\index{header file!stdlib.h} +\index{} +\index{EXIT\_SUCCESS} +\index{EXIT\_FAILURE} +The C standard library \texttt{} provides two predefined constants {\tt EXIT\_SUCCESS} and {\tt EXIT\_FAILURE}. +We can use these to return a descriptive result from our return statement. + + +\begin{verbatim} + #include + int main (void) + { + return EXIT_SUCCESS; /*program terminated successfully*/ + } +\end{verbatim} +% + + +Of course, you might wonder who this value gets returned to, since +we never call {\tt main()} ourselves. It turns out that when the +operating system executes a program, it starts by calling {\tt main()} +in pretty much the same way it calls all the other functions. +When the program terminates it passes a value back +that tells if the execution was successful or not. The operating system +can use this value to create error reports or even pass this value on +to other programs. + +There are even some parameters that can be passed to {\tt main()} +by the system, but we are not going to deal with them for a little +while, so we define {\tt main()} as having no parameters: {\tt int main (void)}. + +%\section {More recursion} +%\index{recursion} +%\index{language!complete} + +%So far we have only learned a small subset of C, but you +%might be interested to know that this subset is now +%a {\bf complete} programming language, by which I +%mean that anything that can be computed can be expressed in this +%language. Any program ever written could be rewritten +%using only the language features we have used so far (actually, we +%would need a few commands to control devices like the keyboard, mouse, +%disks, etc., but that's all). + +%\index{Turing, Alan} + +%Proving that claim is a non-trivial exercise first +%accomplished by Alan Turing, one of the first computer scientists +%(well, some would argue that he was a mathematician, but a lot of the +%early computer scientists started as mathematicians). Accordingly, it +%is known as the Turing thesis. If you take a course on the Theory of +%Computation, you will have a chance to see the proof. + +%To give you an idea of what you can do with the tools we have learned +%so far, we'll evaluate a few recursively-defined +%mathematical functions. A recursive definition is similar to a +%circular definition, in the sense that the definition contains a +%reference to the thing being defined. A truly circular definition is +%typically not very useful: + +%\begin{description} + +%\item[frabjuous:] an adjective used to describe +%something that is frabjuous. + +%\index{frabjuous} + +%\end{description} + +%If you saw that definition in the dictionary, you might be +%annoyed. On the other hand, if you looked up the definition +%of the mathematical function {\bf factorial}, you might +%get something like: + +%\begin{eqnarray*} +%&& 0! = 1 \\ +%&& n! = n \cdot (n-1)! +%\end{eqnarray*} + +%(Factorial is usually denoted with the symbol $!$, which is +%not to be confused with the C logical operator {\tt !} which +%means NOT.) This definition says that the factorial of 0 is 1, +%and the factorial of any other value, $n$, is $n$ multiplied +%by the factorial of $n-1$. So $3!$ is 3 times $2!$, which is 2 times +%$1!$, which is 1 times 0!. Putting it all together, we get +%$3!$ equal to 3 times 2 times 1 times 1, which is 6. + +%If you can write a recursive definition of something, you can usually +%write a C program to evaluate it. The first step is to decide what +%the parameters are for this function, and what the return type is. +%With a little thought, you should conclude that factorial takes an +%integer as a parameter and returns an integer: + +%\begin{verbatim} +% int factorial (int n) +% { +% } +%\end{verbatim} +%% +%If the argument happens to be zero, all we have to do is +%return 1: + +%\begin{verbatim} +% int Factorial (int n) +% { +% if (n == 0) +% { +% return 1; +% } +% } +%\end{verbatim} +%% +%Otherwise, and this is the interesting part, we have to make +%a recursive call to find the factorial of $n-1$, and then +%multiply it by $n$. + +%\begin{verbatim} +% int Factorial (int n) +% { +% if (n == 0) +% { +% return 1; +% } +% else +% { +% int recurse = Factorial (n-1); +% int result = n * recurse; +% return result; +% } +% } +%\end{verbatim} +%% +%If we look at the flow of execution for this program, +%it is similar to {\tt nLines} from the previous chapter. +%If we call {\tt factorial} with the value 3: + +%Since 3 is not zero, we take the second branch and calculate +%the factorial of $n-1$... + +%\begin{quote} +%Since 2 is not zero, we take the second branch and calculate +%the factorial of $n-1$... + +%\begin{quote} +%Since 1 is not zero, we take the second branch and calculate +%the factorial of $n-1$... + +%\begin{quote} +%Since 0 {\em is} zero, we take the first branch and return +%the value 1 immediately without making any more recursive +%calls. + +%\end{quote} + +%The return value (1) gets multiplied by {\tt n}, which is 1, +%and the result is returned. + +%\end{quote} + +%The return value (1) gets multiplied by {\tt n}, which is 2, +%and the result is returned. + +%\end{quote} + +%\noindent The return value (2) gets multiplied by {\tt n}, which is 3, +%and the result, 6, is returned to {\tt main}, or whoever +%called {\tt Factorial (3)}. + +%\index{stack} +%\index{diagram!state} +%\index{diagram!stack} + +%Here is what the stack diagram looks like for this sequence of +%function calls: + +%\vspace{0.1in} +%\centerline{\epsfig{figure=figs/stack3.eps}} +%\vspace{0.1in} +%% +%The return values are shown being passed back up the stack. + +%Notice that in the last instance of {\tt factorial}, the local +%variables {\tt recurse} and {\tt result} do not exist because +%when {\tt n=0} the branch that creates them does not execute. + +%\section{Leap of faith} +%\index{leap of faith} + +%Following the flow of execution is one way to read programs, but as +%you saw in the previous section, it can quickly become labarynthine. +%An alternative is what I call the ``leap of faith.'' When you come to +%a function call, instead of following the flow of execution, you +%{\em assume} that the function works correctly and returns the +%appropriate value. + +%In fact, you are already practicing this leap of faith +%when you use built-in functions. When you call {\tt cos} +%or {\tt exp}, you don't examine the implementations of +%those functions. You just assume that they work, because the people +%who wrote the built-in libraries were good programmers. + +%Well, the same is true when you call one of your own functions. +%For example, in Section~\ref{bool} we wrote a function called +%{\tt IsSingleDigit} that determines whether a number is between +%0 and 9. Once we have convinced ourselves that this function +%is correct---by testing and examination of the code---we can +%use the function without ever looking at the code again. + +%The same is true of recursive programs. When you get to the recursive +%call, instead of following the flow of execution, you should {\em +%assume} that the recursive call works (yields the correct result), and +%then ask yourself, ``Assuming that I can find the factorial of $n-1$, +%can I compute the factorial of $n$?'' In this case, it is clear that +%you can, by multiplying by $n$. + +%Of course, it is a bit strange to assume that the function works +%correctly when you have not even finished writing it, but that's why +%it's called a leap of faith! + +%\section{One more example} +%\index{factorial} + +%In the previous example I used temporary variables to spell out the +%steps, and to make the code easier to debug, but I could have saved a +%few lines: + +%\begin{verbatim} +% int Factorial (int n) +% { +% if (n == 0) +% { +% return 1; +% } +% else +% { +% return n * Factorial (n-1); +% } +% } +%\end{verbatim} +%% +%From now on I will tend to use the more concise version, but +%I recommend that you use the more explicit version while you +%are developing code. When you have it working, you can +%tighten it up, if you are feeling inspired. + +%After {\tt Factorial}, the classic example of a recursively-defined +%mathematical function is {\tt Fibonacci}, which has the +%following definition: + +%\begin{eqnarray*} +%&& fibonacci(0) = 1 \\ +%&& fibonacci(1) = 1 \\ +%&& fibonacci(n) = fibonacci(n-1) + fibonacci(n-2); +%\end{eqnarray*} +%% +%Translated into C, this is + +%\begin{verbatim} +% int Fibonacci (int n) +% { +% if (n == 0 || n == 1) +% { +% return 1; +% } +% else +% { +% return Fibonacci (n-1) + Fibonacci (n-2); +% } +% } +%\end{verbatim} +%% +%If you try to follow the flow of execution here, even for fairly small +%values of {\tt n}, your head explodes. But according to the leap of +%faith, if we assume that the two recursive calls (yes, you can make +%two recursive calls) work correctly, then it is clear that we get the +%right result by adding them together. + +\section{Glossary} + +\begin{description} + +\item[return type:] The type of value a function returns. + +\item[return value:] The value provided as the result of a function +call. + +\item[dead code:] Part of a program that can never be executed, +often because it appears after a {\tt return} statement. + +\item[scaffolding:] Code that is used during program development +but is not part of the final version. + +\item[void:] A special return type that indicates a void function; +that is, one that does not return a value. + + +\item[boolean:] A value or variable that can take on one of +two states, often called $true$ and $false$. In C, boolean +values are mainly stored in variables of type {\tt short} and +preprocessor statements are used to define the states. + +\item[flag:] A variable that records +a condition or status information. + +\item[comparison operator:] An operator that compares two values +and produces a boolean that indicates the relationship between the +operands. + +\item[logical operator:] An operator that combines boolean values +in order to test compound conditions. + +\index{return type} +\index{return value} +\index{dead code} +\index{scaffolding} +\index{void} +\index{bool} +\index{operator!conditional} +\index{operator!logical} + +\end{description} + +\section{Exercises} +\setcounter{exercisenum}{0} + + +\input{exercises/Exercise_5_english} + diff --git a/Chapter6_Iteration.tex b/Chapter6_Iteration.tex new file mode 100644 index 0000000..9b501a0 --- /dev/null +++ b/Chapter6_Iteration.tex @@ -0,0 +1,730 @@ +% LaTeX source for textbook ``How to think like a computer scientist'' +% Copyright (C) 1999 Allen B. Downey +% Copyright (C) 2009 Thomas Scheffler + +\chapter{Iteration} + +\section{Multiple assignment} +\index{assignment} +\index{statement!assignment} +\index{multiple assignment} + +I haven't said much about it, but it is legal in C to +make more than one assignment to the same variable. The +effect of the second assignment is to replace the old value +of the variable with a new value. + +\begin{verbatim} + int fred = 5; + printf ("%i", fred); + fred = 7; + printf ("%i", fred); +\end{verbatim} +% +The output of this program is {\tt 57}, because the first +time we print {\tt fred} his value is 5, and the second time +his value is 7. + +This kind of {\bf multiple assignment} is the reason I +described variables as a {\em container} for values. When +you assign a value to a variable, you change the contents of +the container, as shown in the figure: + +\vspace{0.1in} +\centerline{\includegraphics[height=1.8cm]{figs/assign2.pdf}} +\vspace{0.1in} + +When there are multiple assignments to a variable, it is especially +important to distinguish between an assignment statement and a +statement of equality. Because C uses the {\tt =} symbol for +assignment, it is tempting to interpret a statement like {\tt a = b} +as a statement of equality. It is not! + +First of all, equality is commutative, and assignment is not. +For example, in mathematics if $a = 7$ then $7 = a$. But in +C the statement {\tt a = 7;} is legal, and {\tt 7 = a;} +is not. + +Furthermore, in mathematics, a statement of equality is true +for all time. If $a = b$ now, then $a$ will always equal $b$. +In C, an assignment statement can make two variables equal, +but they don't have to stay that way! + +\begin{verbatim} + int a = 5; + int b = a; /* a and b are now equal */ + a = 3; /* a and b are no longer equal */ +\end{verbatim} +% +The third line changes the value of {\tt a} but it does not +change the value of {\tt b}, and so they are no longer equal. +In many programming languages an alternate symbol is used +for assignment, such as {\tt <-} or {\tt :=}, in order to +avoid confusion. + +Although multiple assignment is frequently useful, you should +use it with caution. If the values of variables are changing +constantly in different parts of the program, it can make +the code difficult to read and debug. + +\section{Iteration} +\index{iteration} + +One of the things computers are often used for is the automation +of repetitive tasks. Repeating identical or similar tasks without +making errors is something that computers do well and people do +poorly. + +In section \ref{recursion} we have seen programs that use {\bf recursion} to perform +repetition, such as {\tt PrintLines()} and {\tt Countdown()}. +I now want to introduce a new +type of repetition, that is called {\bf iteration}, and C provides +several language features that make it easier to write repetetive +programs. + +The two features we are going to look at are the {\tt while} +statement and the {\tt for} statement. + +\section{The {\tt while} statement} +\index{statement!while} +\index{while statement} + +Using a {\tt while} statement, we can rewrite {\tt Countdown()}: + +\begin{verbatim} + void Countdown (int n) + { + while (n > 0) + { + printf ("%i\n", n); + n = n-1; + } + printf ("Blastoff!\n"); + } +\end{verbatim} +% +You can almost read a {\tt while} statement as if it were +English. What this means is, ``While {\tt n} is greater than +zero, continue displaying the value of {\tt n} and then reducing +the value of {\tt n} by 1. When you get to zero, output the +word `Blastoff!''' + +More formally, the flow of execution for a {\tt while} statement +is as follows: + +\begin{enumerate} + +\item Evaluate the condition in parentheses, yielding {\tt true} +or {\tt false}. + +\item If the condition is false, exit the {\tt while} statement +and continue execution at the next statement. + +\item If the condition is true, execute each of the statements +between the curly-brackets, and then go back to step 1. + +\end{enumerate} + +This type of flow is called a {\bf loop} because the third step loops +back around to the top. Notice that if the condition is false the +first time through the loop, the statements inside the loop are +never executed. The statements inside the loop are called +the {\bf body} of the loop. + +\index{loop} +\index{loop!body} +\index{loop!infinite} +\index{body!loop} +\index{infinite loop} + +The body of the loop should change the value of +one or more variables so that, eventually, the condition becomes +false and the loop terminates. Otherwise the loop will repeat +forever, which is called an {\bf infinite loop}. An endless +source of amusement for computer scientists is the observation +that the directions on shampoo, ``Lather, rinse, repeat,'' are +an infinite loop. + +In the case of {\tt Countdown()}, we can prove that the loop +will terminate because we know that the value of {\tt n} is +finite, and we can see that the value of {\tt n} gets smaller +each time through the loop (each {\bf iteration}), so +eventually we have to get to zero. In other cases it is not +so easy to tell: + +\begin{verbatim} + void Sequence (int n) + { + while (n != 1) + { + printf ("%i\n", n); + if (n%2 == 0) /* n is even */ + { + n = n / 2; + } + else /* n is odd */ + { + n = n*3 + 1; + } + } + } +\end{verbatim} +% +The condition for this loop is {\tt n != 1}, so the loop +will continue until {\tt n} is 1, which will make the condition +false. + +At each iteration, the program outputs the value of {\tt n} and then +checks whether it is even or odd. If it is even, the value of +{\tt n} is divided by two. If it is odd, the value is replaced +by $3n+1$. For example, if the starting value (the argument passed +to {\tt Sequence}) is 3, the resulting sequence is +3, 10, 5, 16, 8, 4, 2, 1. + +Since {\tt n} sometimes increases and sometimes decreases, there is no +obvious proof that {\tt n} will ever reach 1, or that the program will +terminate. For some particular values of {\tt n}, we can prove +termination. For example, if the starting value is a power of two, then +the value of {\tt n} will be even every time through the loop, until +we get to 1. The previous example ends with such a sequence, +starting with 16. + +Particular values aside, the interesting question is whether +we can prove that this program terminates for {\em all} values of n. +So far, no one has been able to prove it {\em or} disprove it! + +\section{Tables} +\index{table} +\index{logarithm} + +One of the things loops are good for is generating +tabular data. For example, before computers were readily available, +people had to calculate logarithms, sines and cosines, and other +common mathematical functions by hand. +To make that easier, there were books containing long tables +where you could find the values of various functions. +Creating these tables was slow and boring, and the result +tended to be full of errors. + +When computers appeared on the scene, one of the initial reactions +was, ``This is great! We can use the computers to generate the +tables, so there will be no errors.'' That turned out to be true +(mostly), but shortsighted. Soon thereafter computers and +calculators were so pervasive that the tables became obsolete. + +Well, almost. It turns out that for some operations, computers +use tables of values to get an approximate answer, and then +perform computations to improve the approximation. In some +cases, there have been errors in the underlying tables, most +famously in the table the original Intel Pentium used to perform +floating-point division. + +\index{division!floating-point} + +Although a ``log table'' is not as useful as it once was, it still +makes a good example of iteration. The following program outputs a +sequence of values in the left column and their logarithms in the +right column: + +\begin{verbatim} + double x = 1.0; + while (x < 10.0) + { + printf ("%.0f\t%f\n", x ,log(x)); + x = x + 1.0; + } +\end{verbatim} +% +The sequence \verb+\t+ represents a {\bf tab} character. +The sequence \verb+\n+ represents a newline character. +They are so called \emph{escape sequences} which are used to encode +non-printable ASCII-characters. +Escape sequences can be included anywhere in a string, although in these examples +the sequence is the whole string. + +A tab character causes the cursor to shift to the right until +it reaches one of the {\bf tab stops}, which are normally every +eight characters. As we will see in a minute, tabs are useful +for making columns of text line up. +A newline character causes the cursor to move on to the next line. +%Usually if a newline character appears by itself, I use {\tt endl}, but +%if it appears as part of a string, I use \verb+\n+. + +The output of this program is: + +\begin{verbatim} + 1 0.000000 + 2 0.693147 + 3 1.098612 + 4 1.386294 + 5 1.609438 + 6 1.791759 + 7 1.945910 + 8 2.079442 + 9 2.197225 +\end{verbatim} +% +If these values seem odd, remember that the {\tt log()} function uses +base $e$. Since powers of two are so important in computer science, +we often want to find logarithms with respect to base 2. To do that, +we can use the following formula: + +\[ \log_2 x = \frac {log_e x}{log_e 2} \] +% +Changing the output statement to + +\begin{verbatim} + printf ("%.0f\t%f\n", x, log(x) / log(2.0)); +\end{verbatim} +% +yields: + +\begin{verbatim} + 1 0.000000 + 2 1.000000 + 3 1.584963 + 4 2.000000 + 5 2.321928 + 6 2.584963 + 7 2.807355 + 8 3.000000 + 9 3.169925 +\end{verbatim} +% +We can see that 1, 2, 4 and 8 are powers of two, because +their logarithms base 2 are round numbers. If we wanted to find +the logarithms of other powers of two, we could modify the +program like this: + +\begin{verbatim} + double x = 1.0; + while (x < 100.0) + { + printf ("%.0f\t%.0f\n", x, log(x) / log(2.0)); + x = x * 2.0; + } +\end{verbatim} +% +Now instead of adding something to {\tt x} each time through +the loop, which yields an arithmetic sequence, we multiply +{\tt x} by something, yielding a {\bf geometric} sequence. +The result is: + +\begin{verbatim} + 1 0 + 2 1 + 4 2 + 8 3 + 16 4 + 32 5 + 64 6 +\end{verbatim} +% +Because we are using tab characters between the columns, the +position of the second column does not depend on the number +of digits in the first column. + +Log tables may not be useful any more, but for computer scientists, +knowing the powers of two is! As an exercise, modify this program +so that it outputs the powers of two up to 65536 +(that's $2^{16}$). Print it out and memorize it. + +\section{Two-dimensional tables} +\index{table!two-dimensional} + +A two-dimensional table is a table where you choose a row and +a column and read the value at the intersection. A multiplication +table is a good example. Let's say you wanted to print a +multiplication table for the values from 1 to 6. + +A good way to start is to write a simple loop that prints +the multiples of 2, all on one line. + +\begin{verbatim} + int i = 1; + while (i <= 6) + { + printf("%i ", i*2); + i = i + 1; + } + printf("\n"); +\end{verbatim} +% +The first line initializes a variable named {\tt i}, which is +going to act as a counter, or {\bf loop variable}. As the +loop executes, the value of {\tt i} increases from 1 to 6, +and then when {\tt i} is 7, the loop terminates. Each +time through the loop, we print the value {\tt 2*i} followed +by three spaces. By omitting the \verb+\n+ from the +first output statement, we get +all the output on a single line. + +\index{loop variable} +\index{variable!loop} + +The output of this program is: + +\begin{verbatim} + 2 4 6 8 10 12 +\end{verbatim} +% +So far, so good. The next step is to {\bf encapsulate} and {\bf +generalize}. + +\section {Encapsulation and generalization} + +Encapsulation usually means taking a piece of code and wrapping it up +in a function, allowing you to take advantage of all the things functions +are good for. We have seen two examples of encapsulation, when we +wrote {\tt PrintParity()} in Section~\ref{alternative} and {\tt +IsSingleDigit()} in Section~\ref{bool}. + +Generalization means taking something specific, like printing +multiples of 2, and making it more general, like printing the +multiples of any integer. + +\index{encapsulation} +\index{generalization} + +Here's a function that encapsulates the loop from the previous +section and generalizes it to print multiples of {\tt n}. + +\begin{verbatim} + void PrintMultiples (int n) + { + int i = 1; + while (i <= 6) + { + printf("%i ", i*n); + i = i + 1; + } + printf("\n"); + } +\end{verbatim} +% +To encapsulate, all I had to do was add the first line, +which declares the name, parameter, +and return type. To generalize, all I had to do was replace +the value 2 with the parameter {\tt n}. + +If we call this function with the argument 2, we get the same +output as before. With argument 3, the output is: + +\begin{verbatim} + 3 6 9 12 15 18 +\end{verbatim} +% +and with argument 4, the output is + +\begin{verbatim} + 4 8 12 16 20 24 +\end{verbatim} +% +By now you can probably guess how we are going to print a +multiplication table: we'll call {\tt PrintMultiples()} repeatedly with +different arguments. In fact, we are going to use another loop to +iterate through the rows. + +\begin{verbatim} + int i = 1; + while (i <= 6) + { + PrintMultiples (i); + i = i + 1; + } +\end{verbatim} +% +First of all, notice how similar this loop is to the one inside {\tt +PrintMultiples()}. I only replaced the call of the \texttt{printf()} function with +the call of the \texttt{PrintMultiples()} function. + +The output of this program is + +\begin{verbatim} + 1 2 3 4 5 6 + 2 4 6 8 10 12 + 3 6 9 12 15 18 + 4 8 12 16 20 24 + 5 10 15 20 25 30 + 6 12 18 24 30 36 +\end{verbatim} +% +which is a (slightly sloppy) multiplication table. If the +sloppiness bothers you, try replacing the spaces between +columns with tab characters and see what you get. + +\section{Functions} +\index{function} + +In the last section I mentioned ``all the things functions +are good for.'' About this time, you might be wondering +what exactly those things are. Here are some of the reasons +functions are useful: + +\begin{itemize} + +\item By giving a name to a sequence of statements, you make +your program easier to read and debug. + +\item Dividing a long program into functions allows you to +separate parts of the program, debug them in isolation, and +then compose them into a whole. + +\item Functions facilitate both recursion and iteration. + +\item Well-designed functions are often useful for many programs. +Once you write and debug one, you can reuse it. + +\end{itemize} + +\section{More encapsulation} +\index{encapsulation} +\index{program development!encapsulation} + +To demonstrate encapsulation again, I'll take the code +from the previous section and wrap it up in a function: + +\begin{verbatim} + void PrintMultTable () + { + int i = 1; + while (i <= 6) + { + PrintMultiples (i); + i = i + 1; + } + } +\end{verbatim} +% +The process I am demonstrating is a common +development plan. You develop code gradually by adding +lines to {\tt main()} or someplace else, and then when you get +it working, you extract it and wrap it up in a function. + +The reason this is useful is that you sometimes don't know +when you start writing exactly how to divide the program into +functions. This approach lets you design as you go along. + +\section{Local variables} + +About this time, you might be wondering how we can use the same +variable {\tt i} in both {\tt PrintMultiples()} and {\tt +PrintMultTable()}. Didn't I say that you can only declare a variable +once? And doesn't it cause problems when one of the functions changes +the value of the variable? + +The answer to both questions is ``no,'' because the {\tt i} in {\tt +PrintMultiples()} and the {\tt i} in {\tt PrintMultTable()} are +{\em not the same variable}. They have the same name, but +they do not refer to the same storage location, and changing +the value of one of them has no effect on the other. + +\index{local variable} +\index{variable!local} + +Remember that variables that are declared inside a function definition +are local. You cannot access a local variable from outside its +``home'' function, and you are free to have multiple variables with +the same name, as long as they are not in the same function. + +The stack diagram for this program shows clearly that the +two variables named {\tt i} are not in the same storage location. +They can have different values, and changing one does not affect +the other. + + +\vspace{0.1in} +\centerline{\epsfig{figure=figs/stack4.pdf,width=6.5cm}} +\vspace{0.1in} +\index{stack diagram} +\index{diagram!stack} +% +Notice that the value of the parameter {\tt n} in +{\tt PrintMultiples()} has to be the same as the value +of {\tt i} in {\tt PrintMultTable()}. On the other hand, +the value of {\tt i} in {\tt PrintMultiples()} goes +from 1 up to {\tt 6}. In the diagram, it happens to be 3. +The next time through the loop it will be 4. + +It is often a good idea to use different variable names in +different functions, to avoid confusion, but there are good +reasons to reuse names. For example, it is common to +use the names {\tt i}, {\tt j} and {\tt k} as loop variables. +If you avoid using them in one function just because you +used them somewhere else, you will probably make the program +harder to read. + +\index{loop variable} +\index{variable!loop} + +%% +\section{More generalization} +\label{More generalization} +\index{generalization} + +As another example of generalization, imagine you wanted +a program that would print a multiplication table of any +size, not just the 6x6 table. You could add a parameter to +{\tt PrintMultTable()}: + +\begin{verbatim} + void PrintMultTable (int high) + { + int i = 1; + while (i <= high) + { + PrintMultiples (i); + i = i + 1; + } + } +\end{verbatim} +% +I replaced the value 6 with the parameter {\tt high}. If I +call {\tt PrintMultTable()} with the argument 7, I get: + +\begin{verbatim} + 1 2 3 4 5 6 + 2 4 6 8 10 12 + 3 6 9 12 15 18 + 4 8 12 16 20 24 + 5 10 15 20 25 30 + 6 12 18 24 30 36 + 7 14 21 28 35 42 +\end{verbatim} +% +which is fine, except that I probably want the table to +be square (same number of rows and columns), which means +I have to add another parameter to {\tt PrintMultiples()}, +to specify how many columns the table should have. + +Just to be annoying, I will also call this parameter {\tt high}, +demonstrating that different functions can have parameters +with the same name (just like local variables): + +\begin{verbatim} + void PrintMultiples (int n, int high) + { + int i = 1; + while (i <= high) + { + printf ("%i ", n*i); + i = i + 1; + } + printf ("\n"); + } + + void PrintMultTable (int high) + { + int i = 1; + while (i <= high) + { + PrintMultiples (i, high); + i = i + 1; + } + } +\end{verbatim} +% +Notice that when I added a new parameter, I had to change the first +line of the function, and I also had to +change the place where the function is called in {\tt PrintMultTable()}. +As expected, this program generates a square 7x7 table: + +\begin{verbatim} + 1 2 3 4 5 6 7 + 2 4 6 8 10 12 14 + 3 6 9 12 15 18 21 + 4 8 12 16 20 24 28 + 5 10 15 20 25 30 35 + 6 12 18 24 30 36 42 + 7 14 21 28 35 42 49 +\end{verbatim} +% +When you generalize a function appropriately, you often find +that the resulting program has capabilities you did not intend. +For example, you might notice that the multiplication table +is symmetric, because $ab = ba$, so all the entries in the +table appear twice. You could save ink by printing only +half the table. To do that, you only have to change one +line of {\tt PrintMultTable()}. Change + +\begin{verbatim} + PrintMultiples (i, high); +\end{verbatim} +% +to + +\begin{verbatim} + PrintMultiples (i, i); +\end{verbatim} +% +and you get: + +\begin{verbatim} + 1 + 2 4 + 3 6 9 + 4 8 12 16 + 5 10 15 20 25 + 6 12 18 24 30 36 + 7 14 21 28 35 42 49 +\end{verbatim} +% +I'll leave it up to you to figure out how it works. + +\section{Glossary} + +\begin{description} + +\item[loop:] A statement that executes repeatedly while a +condition is true or until some condition is satisfied. + +\item[infinite loop:] A loop whose condition is always true. + +\item[body:] The statements inside the loop. + +\item[iteration:] One pass through (execution of) the body +of the loop, including the evaluation of the condition. + +\item[tab:] A special character, written as \verb+\t+ in C, +that causes the cursor to move to the next tab stop on the +current line. + +\item[encapsulate:] To divide a large complex program into +components (like functions) and isolate the components from +each other (for example, by using local variables). + +\item[local variable:] A variable that is declared inside +a function and that exists only within that function. Local variables +cannot be accessed from outside their home function, and do not +interfere with any other functions. + +\item[generalize:] To replace something unnecessarily specific +(like a constant value) with something appropriately general +(like a variable or parameter). Generalization makes code more +versatile, more likely to be reused, and sometimes even easier +to write. + +\item[development plan:] A process for developing a program. +In this chapter, I demonstrated a style of development based on +developing code to do simple, specific things, and then encapsulating +and generalizing. + +\index{loop} +\index{infinite loop} +\index{body} +\index{tab} +\index{loop!infinite} +\index{iteration} +\index{encapsulation} +\index{generalization} +\index{local variable} +\index{variable!local} +\index{program development} + +\end{description} + +\section{Exercises} +\setcounter{exercisenum}{0} + +\input{exercises/Exercise_6_english} + diff --git a/Chapter7_Array.tex b/Chapter7_Array.tex new file mode 100644 index 0000000..f45b789 --- /dev/null +++ b/Chapter7_Array.tex @@ -0,0 +1,899 @@ +% LaTeX source for textbook ``How to think like a computer scientist'' +% Copyright (C) 1999 Allen B. Downey +% Copyright (C) 2009 Thomas Scheffler + + +\chapter{Arrays} +\label{arrays} +\index{arrays} +\index{type!array} + +A {\bf array} is a set of values where each value is identified and referenced by a +number (called an index). The nice thing +about arrays is that they can be made up of any type of element, +including basic types like {\tt int}s and {\tt double}s, +but all the values in an array have to have the same type. +%and user-defined types like {\tt Point} and {\tt Time}. + + +When you declare an array, you have to determine the number of +elements in the array. Otherwise the declaration looks similar to other variable types: + +\begin{verbatim} + int c[4]; + double values[10]; +\end{verbatim} + + +% + +Syntactically, array variables look like other C variables except that they are followed +by {\tt [NUMBER\_OF\_ELEMENTS]}, the number of elements in the array enclosed in square brackets. +The first line in our example, {\tt int c[4];} is of the type "array of integers" and creates a array of four integers named {\tt c}. +The second line, {\tt double values[10];} has the type "array of doubles" and + creates an array of 10 {\tt double}s. + +%The number +%of elements in {\tt values} depends on {\tt size}. You can use any +%integer expression to determine the size of an array. +%!!! Not in C +%this would be dynamic arrays, that can not be initialised at definition time!!! + +% + +C allows you to to initialize the element values of an array immediately +after you have declared it. The values for the individual elements must be +enclosed in curly brakets {\tt \{\}} and separated by comma, as in the following example: + +\begin{verbatim} + int c[4] = {0, 0, 0, 0}; +\end{verbatim} + +This statement creates an array of four elements and initializes +all of them to zero. +This syntax is only legal at initialisation time. Later in your program you can only +assign values for the array element by element. + +% +The following figure shows how arrays are represented in state +diagrams: + +%\myfig{figure=figs/array.eps} + +\unitlength0.1cm + +\begin{picture}(40,10)(-30,-5) +%\put(-4,1.5){{\Large \texttt{c}}} +%\put(0,1.5){\framebox(2,2)} +%\thicklines +%\put(2,2.5){\vector(1,0){8}} +%\thinlines +\put(5,1.5){{\Large \texttt{c}}} +\put(10,0){\framebox(7,5){\textbf{\textsf{0}}}} +\put(17,0){\framebox(7,5){\textbf{\textsf{0}}}} +\put(24,0){\framebox(7,5){\textbf{\textsf{0}}}} +\put(31,0){\framebox(7,5){\textbf{\textsf{0}}}} + +\put(10.5,-4){{\scriptsize \texttt{c[0]}}} +\put(17.5,-4){{\scriptsize \texttt{c[1]}}} +\put(24.5,-4){{\scriptsize \texttt{c[2]}}} +\put(31.5,-4){{\scriptsize \texttt{c[3]}}} + +\end{picture} + +The large numbers inside the boxes are the values of the {\bf elements} in +the array. The small numbers outside the boxes are the +indices used to identify each box. When you allocate a new +array, without initializing, the arrays elements typically +contain arbitrary values and you must initialise them to +a meaningful value before using them. + + +%% +\section{Increment and decrement operators} +\index{operator!increment} +\index{operator!decrement} +\index{increment} +\index{decrement} + +Incrementing and decrementing are such common operations that C +provides special operators for them. The {\tt ++} operator adds one +to the current value of an {\tt int}, {\tt char} or {\tt double}, and +{\tt -}{\tt -} subtracts one. +%Neither operator works on {\tt apstring}s, +%and neither {\em should} be used on {\tt bool}s. + +Technically, it is legal to increment a variable and use it +in an expression at the same time. For example, you might see +something like: + +\begin{verbatim} + printf ("%i\n ", i++); +\end{verbatim} +% +Looking at this, it is not clear whether the increment will +take effect before or after the value is displayed. Because +expressions like this tend to be confusing, I would discourage +you from using them. In fact, to discourage you even more, +I'm not going to tell you what the result is. If you really +want to know, you can try it. + +Using the increment operators, we can rewrite the {\tt PrintMultTable()} from Section~\ref{More generalization}: + +\begin{verbatim} + void PrintMultTable(int high) + { + int i = 1; + while (i <= high) + { + PrintMultiples(i); + i++; + } + } +\end{verbatim} +% +It is a common error to write something like: + +\begin{verbatim} + index = index++; /* WRONG!! */ +\end{verbatim} +% +Unfortunately, this is syntactically legal, so the compiler +will not warn you. The effect of this statement is to leave +the value of {\tt index} unchanged. This is often a difficult +bug to track down. + +Remember, you can write {\tt index = index + 1;}, or you +can write {\tt index++;}, but you shouldn't mix them. + +%% +\section{Accessing elements} +\index{element} +\index{array!element} + +The {\tt []} operator allows us to read and write the individual elements of an array. +The indices start at zero, so {\tt c[0]} +refers to the first element of the array, and {\tt c[1]} +refers to the second element. You can use the {\tt []} operator +anywhere in an expression: + + +\begin{verbatim} + c[0] = 7; + c[1] = c[0] * 2; + c[2]++; + c[3] -= 60; +\end{verbatim} +% +All of these are legal assignment statements. Here is the +effect of this code fragment: + + +%\myfig{figure=figs/array2.eps} + +\unitlength0.1cm + +\begin{picture}(40,10)(-30,-5) +%\put(-11,1.5){\texttt{count}} +%\put(0,1.5){\framebox(2,2)} +%\thicklines +%\put(2,2.5){\vector(1,0){8}} +%\thinlines +\put(5,1.5){{\Large \texttt{c}}} + +\put(10,0){\framebox(7,5){\textbf{\textsf{7}}}} +\put(17,0){\framebox(7,5){\textbf{\textsf{14}}}} +\put(24,0){\framebox(7,5){\textbf{\textsf{1}}}} +\put(31,0){\framebox(7,5){\textbf{\textsf{-60}}}} + +\put(10.5,-4){{\scriptsize \texttt{c[0]}}} +\put(17.5,-4){{\scriptsize \texttt{c[1]}}} +\put(24.5,-4){{\scriptsize \texttt{c[2]}}} +\put(31.5,-4){{\scriptsize \texttt{c[3]}}} + +\end{picture} + +By now you should have noticed that the four elements of this array +are numbered from 0 to 3, which means that there is no element with +the index 4. + +Nevertheless, it is a common error to go +beyond the bounds of an array. In safer languages such as Java, this will cause an +error and most likely the program quits. C does not check array boundaries, so +your program can go on accessing memory locations beyond the array itself, as if +they where part of the array. This is most likely wrong and can cause very +severe bugs in your program. +\begin{quote} + +{\bf It is necessary that you, as a programmer, +make sure that your code correctly observes array boundaries!} + +\end{quote} + + + + +\index{run-time error} +\index{index} +\index{expression} + +You can use any expression as an index, as long as it has type {\tt +int}. One of the most common ways to index an array is with a loop +variable. For example: + +\begin{verbatim} + int i = 0; + while (i < 4) + { + printf ("%i\n", c[i]); + i++; + } +\end{verbatim} + +% +This is a standard {\tt while} loop that counts from 0 +up to 4, and when the loop variable {\tt i} is 4, the +condition fails and the loop terminates. Thus, the body +of the loop is only executed when {\tt i} is 0, 1, 2 and 3. + +\index{loop} +\index{loop variable} +\index{variable!loop} + +Each time through the loop we use {\tt i} as an index into +the array, printing the {\tt i}th element. This type of +array traversal is very common. Arrays and loops go together +like fava beans and a nice Chianti. + +\index{fava beans} +\index{Chianti} + +%% +\section{Copying arrays} +\index{array!copying} + +Arrays can be a very convenient solution for a number of problems, like +storing and processing large sets of data. + +However, there is very little that C does automatically for you. For example +you can not set all the elements of an array at the same time and you can not +assign one array to the other, even if they are identical in type and number of elements. + + +\begin{verbatim} + double a[3] = {1.0, 1.0, 1.0}; + double b[3]; + + a = 0.0; /* Wrong! */ + b = a; /* Wrong! */ +\end{verbatim} +% + +In order to set all of the elements of an array to some value, you must do so element by element. +To copy the contents of one array to another, you must again do so, by copying each element from +one array to the other. + +\begin{verbatim} + int i = 0; + while (i < 3) + { + b[i] = a[i]; + i++; + } +\end{verbatim} + +%% +\section{{\tt for} loops} + +The loops we have written so far have a number of elements +in common. All of them start by initializing a variable; +they have a test, or condition, that depends on that variable; +and inside the loop they do something to that variable, +like increment it. + +\index{loop!for} +\index{for} +\index{statement!for} + +This type of loop is so common that there is an alternate +loop statement, called {\tt for}, that expresses it more +concisely. The general syntax looks like this: + +\begin{verbatim} + for (INITIALIZER; CONDITION; INCREMENTOR) + { + BODY + } +\end{verbatim} +% +This statement is exactly equivalent to + +\begin{verbatim} + INITIALIZER; + while (CONDITION) + { + BODY + INCREMENTOR + } +\end{verbatim} +% +except that it is more concise and, since it puts all the +loop-related statements in one place, it is easier to read. +For example: + +\begin{verbatim} + int i; + for (i = 0; i < 4; i++) + { + printf("%i\n", c[i]); + } +\end{verbatim} +% +is equivalent to + +\begin{verbatim} + int i = 0; + while (i < 4) + { + printf("%i\n", c[i]); + i++; + } +\end{verbatim} + +%% +\section{Array length} +\label{Array length} +\index{length!array} +\index{array!length} +\index{sizeof} +\index{operator!sizeof} + +C does not provide us with a convenient way to determine the +actual length of an array. Knowing the size of an array would +be convenient when we are looping through all elements of +the array and need to stop with the last element. + +In order to determine the array length we could use the {\tt sizeof()} +operator, that calculates the size of data types in bytes. +Most data types in C use more than one byte to store their values, +therefore it becomes necessary to divide the byte-count for the array by +the byte-count for a single element to establish the number of elements +in the array. +\begin{verbatim} + sizeof(ARRAY)/sizeof(ARRAY_ELEMENT) +\end{verbatim} + +It is a good idea to use this value as the upper bound of a loop, +rather than a constant. That way, if the size of the array +changes, you won't have to go through the program changing all the +loops; they will work correctly for any size array. + +\begin{verbatim} + int i, length; + length = sizeof (c) / sizeof (c[0]); + + for (i = 0; i < length; i++) + { + printf("%i\n", c[i]); + } +\end{verbatim} +% +The last time the body of the loop gets executed, the value of {\tt i} +is {\tt length - 1}, which is the index of the last element. When +{\tt i} is equal to {\tt length}, the condition fails and the body +is not executed, which is a good thing, since it would access a +memory location that is not part of the array. + +\section{Random numbers} +\label{Random numbers} +\label{random} +\label{pseudorandom} +\index{random number} +\index{deterministic} +\index{nondeterministic} + +Most computer programs do the same thing every time they are executed, +so they are said to be {\bf deterministic}. Usually, determinism is a +good thing, since we expect the same calculation to yield the same +result. For some applications, though, we would like the +computer to be unpredictable. Games are an obvious example. + +Making a program truly {\bf nondeterministic} turns out to be not +so easy, but there are ways to make it at least seem +nondeterministic. One of them is to generate {pseudorandom} numbers and +use them to determine the outcome of the program. +Pseudorandom numbers +are not truly random in the mathematical sense, but +for our purposes, they will do. + +\index{header file!stdlib.h} +\index{} + +C provides a function called {\tt rand()} that generates +pseudorandom numbers. It is declared in the +header file {\tt stdlib.h}, which contains a variety of ``standard +library'' functions, hence the name. + +The return value from {\tt rand()} is an integer between 0 and {\tt +RAND\_MAX}, where {\tt RAND\_MAX} is a large number (about 2 billion +on my computer) also defined in the header file. Each time you call +{\tt rand()} you get a different randomly-generated number. To see a +sample, run this loop: + +\begin{verbatim} + for (i = 0; i < 4; i++) + { + int x = rand(); + printf("%i\n", x); + } +\end{verbatim} +% +On my machine I got the following output: + +\begin{verbatim} +1804289383 +846930886 +1681692777 +1714636915 +\end{verbatim} +% +You will probably get something similar, but different, on yours. + +Of course, we don't always want to work with gigantic integers. +More often we want to generate integers between 0 and some +upper bound. A simple way to do that is with the modulus +operator. For example: + +\begin{verbatim} + int x = rand (); + int y = x % upperBound; +\end{verbatim} +% +Since {\tt y} is the remainder when {\tt x} is divided by +{\tt upperBound}, the only possible values for {\tt y} +are between 0 and {\tt upperBound - 1}, including both +end points. Keep in mind, though, that {\tt y} will never +be equal to {\tt upperBound}. + +It is also frequently useful to generate random floating-point values. +A common way to do that is by dividing by {\tt RAND\_MAX}. For +example: + +\begin{verbatim} + int x = rand (); + double y = (double) x / RAND_MAX; +\end{verbatim} +% +This code sets {\tt y} to a random value between 0.0 and 1.0, +including both end points. As an exercise, you might want to +think about how to generate a random floating-point value in +a given range; for example, between 100.0 and 200.0. + +%% +\pagebreak +\section{Statistics} +\index{statistics} +\index{distribution} +\index{mean} + +The numbers generated by {\tt rand()} are supposed to be distributed +uniformly. That means that each value in the range should be +equally likely. If we count the number of times each value appears, +it should be roughly the same for all values, provided that we +generate a large number of values. + +In the next few sections, we will write programs that generate +a sequence of random numbers and check whether this property +holds true. + +%% +\section{Array of random numbers} +\label{Array of random numbers} + +The first step is to generate a large number of random values +and store them in a array. By ``large number,'' of course, +I mean 20. It's always a good idea to start with a manageable +number, to help with debugging, and then increase it later. + +The following function takes three arguments, an array of integers, +the size of the array and an upper bound for the random values. +It fills the array of {\tt int}s with random values between 0 and {\tt upperBound-1}. + +\begin{verbatim} + void RandomizeArray (int array[], int length, int upperBound) + { + int i; + for (i = 0; i < length; i++) + { + array[i] = rand() % upperBound; + } + } +\end{verbatim} +% +The return type is {\tt void}, which means that +this function does not return any value to the calling function. +To test this function, it is convenient to have a function that +outputs the contents of a array. + +\begin{verbatim} + void PrintArray (int array[], int length) + { + int i; + for (i = 0; i < length; i++) + { + printf ("%i ", array[i]); + } + } +\end{verbatim} +% +The following code generates an array filled with random values and outputs it: + +\begin{verbatim} + int r_array[20]; + int upperBound = 10; + int length = sizeof(r_array) / sizeof(r_array[0]); + + RandomizeArray (r_array, length, upperBound); + PrintArray (r_array, length); +\end{verbatim} + +% +On my machine the output is: + +\begin{verbatim} +3 6 7 5 3 5 6 2 9 1 2 7 0 9 3 6 0 6 2 6 +\end{verbatim} +\nopagebreak% +which is pretty random-looking. Your results may differ. + +If these numbers are really random, +we expect each digit to appear the same number of times---twice +each. In fact, the number 6 appears five times, and the numbers 4 +and 8 never appear at all. + +Do these results mean the values are not really uniform? It's +hard to tell. With so few values, the chances are slim +that we would get exactly what we expect. But as the number +of values increases, the outcome should be more predictable. + +To test this theory, we'll write some programs that count the +number of times each value appears, and then see what happens +when we increase the number of elements in our array. + +%% +\section{Passing an array to a function} +\label{Passing an array to a function} +\index{call by reference} +\index{call by value} +\index{array parameters} +You probably have noticed that our {\tt RandomizeArray()} function +looked a bit unusual. We pass an array to this function and expect +to get a a randomized array back. Nevertheless, we have declared it to +be a {\tt void} function, and miraculously the function appears to have +altered the array. + +This behaviour goes against everything what I have said about the +use of variables in functions so far. +C typically uses the so called {\bf call-by-value} evaluation of +expressions. If you pass a value to a function it gets copied from +the calling function to a variable in the called function. The same +is true if the function returns a value. +Changes to the internal variable in the called function do not affect the external +values of the calling function. + +When we pass an array to a function this behaviour changes to +something called {\bf call-by-reference} evaluation. +C does not copy the array to an internal array -- it rather generates a +reference to the original array and any operation in the called function +directly affects the original array. +This is also the reason why we do not have to return anything from our +function. The changes have already taken place. + +Call by reference also makes it necessary to supply the length of +the array to the called function, since invoking the {\tt sizeof} +operator in the called function would determine the size of the reference +and not the original array. + +%!!!Reference to later chapter needed!!! +We will further discuss call by reference and call by value in +Section~\ref{Pointers and Addresses}, Section~\ref{Call by value} and +\ref{Call by reference}. + +%% +\section{Counting} +\label{counting} +\index{traverse!counting} +\index{loop!counting} +\index{counter} + +A good approach to problems like this is to think of simple functions +that are easy to write, and that might turn out to be useful. Then +you can combine them into a solution. This approach is sometimes +called {\bf bottom-up design}. + +Of course, it is not easy to +know ahead of time which functions are likely to be useful, but as you +gain experience you will have a better idea. +\index{bottom-up design} +\index{program development!bottom-up} +Also, it is not always obvious what sort of things are easy to write, +but a good approach is to look for subproblems that fit a pattern you +have seen before. + +\index{pattern!counter} + +%Back in Section~\ref{loopcount} we looked at a loop that traversed a +%string and counted the number of times a given letter appeared. +In our current example we want to examine a potentially large set +of elements and count the number of times a certain value appears. +You +can think of this program as an example of a pattern called ``traverse +and count.'' The elements of this pattern are: + +\begin{itemize} + +\item A set or container that can be traversed, like a string +or a array. + +\item A test that you can apply to each element in the container. + +\item A counter that keeps track of how many elements pass +the test. + +\end{itemize} + +In this case, I have a function in mind called {\tt HowMany()} that +counts the number of elements in a array that are equal to a given value. +The parameters are the array, the length of the array and the integer value we are looking +for. The return value is the number of times the value appears. + +\begin{verbatim} + int HowMany (int array[], int length, int value) + { + int i; + int count = 0; + + for (i=0; i < length; i++) + { + if (array[i] == value) count++; + } + return count; + } +\end{verbatim} + + +\section{Checking the other values} + +{\tt HowMany()} only counts the occurrences of a particular value, and +we are interested in seeing how many times each value appears. +We can solve that problem with a loop: + +\begin{verbatim} + int i; + int r_array[20]; + int upperBound = 10; + int length = sizeof(r_array) / sizeof(r_array[0]); + + RandomizeArray(r_array, length, upperBound); + + printf ("value\tHowMany\n"); + for (i = 0; i < upperBound; i++) + { + printf("%i\t%i\n", i, HowMany(r_array, length, i)); + } +\end{verbatim} +% + +%! ! ! Applies only to C++! ! ! +%Notice that it is legal to declare a variable inside a {\tt for} +%statement. This syntax is sometimes convenient, but you should +%be aware that a variable declared inside a loop only exists +%inside the loop. If you try to refer to {\tt i} later, you +%will get a compiler error. + +This code uses the loop variable as an argument to +{\tt HowMany()}, in order to check each value between 0 and 9, +in order. The result is: + +\begin{verbatim} +value HowMany +0 2 +1 1 +2 3 +3 3 +4 0 +5 2 +6 5 +7 2 +8 0 +9 2 +\end{verbatim} +% +Again, it is hard to tell if the digits are really appearing +equally often. If we increase the size of the array to 100,000 we +get the following: + +\begin{verbatim} +value HowMany +0 10130 +1 10072 +2 9990 +3 9842 +4 10174 +5 9930 +6 10059 +7 9954 +8 9891 +9 9958 +\end{verbatim} +% +In each case, the number of appearances is within about 1\% of +the expected value (10,000), so we conclude that the random +numbers are probably uniform. + +\section {A histogram} +\index{histogram} + +It is often useful to take the data from the previous tables +and store them for later access, rather than just print them. +What we need is a way to store 10 integers. We could create +10 integer variables with names like {\tt howManyOnes}, +{\tt howManyTwos}, etc. But that would require a lot of +typing, and it would be a real pain later if we decided to +change the range of values. + +A better solution is to use a array with length 10. That +way we can create all ten storage locations at once and we +can access them using indices, rather than ten different names. +Here's how: + +\begin{verbatim} + int i; + int upperBound = 10; + int r_array[100000]; + int histogram[upperBound]; + int r_array_length = sizeof(r_array) / sizeof(r_array[0]); + + RandomizeArray(r_array, r_array_length, upperBound); + + for (i = 0; i < upperBound; i++) + { + int count = HowMany(r_array, length, i); + histogram[i] = count; + } +\end{verbatim} +% +I called the array {\bf histogram} because that's +a statistical term for a array of numbers that counts the +number of appearances of a range of values. + +\index{histogram} + +The tricky thing here is that I am using the loop variable +in two different ways. First, it is an argument to {\tt HowMany()}, +specifying which value I am interested in. Second, it is +an index into the histogram, specifying which location I should +store the result in. + +\section{A single-pass solution} + +Although this code works, it is not as efficient as it could +be. Every time it calls {\tt HowMany()}, it traverses the +entire array. In this example we have to traverse the +array ten times! + +It would be better to make a single pass through the array. +For each value in the array we could find the corresponding +counter and increment it. In other words, we can use the +value from the array as an index into the histogram. Here's +what that looks like: + +\begin{verbatim} + int upperBound = 10; + int histogram[upperBound] = {0, 0, 0, 0, 0, 0, 0, 0, 0, 0}; + + for (i = 0; i < r_array_length; i++) + { + int index = r_array[i]; + histogram[index]++; + } +\end{verbatim} +% +The second line initializes the elements of the histogram to +zeroes. That way, when we use the increment +operator ({\tt ++}) inside the loop, we know we are starting from zero. +Forgetting to initialize counters is a common error. + +As an exercise, encapsulate this code in a function called {\tt Histogram()} +that takes an array and the range of values in the array +(in this case 0 through 10) as two parameters \texttt{min} and \texttt{max}. +You should pass a second array to the function where a histogram of the +values in the array can be stored. + +\section{Random seeds} +\label{Random seeds} +\index{seed} +\index{random} + +If you have run the code in this chapter a few times, you might +have noticed that you are getting the same ``random'' values +every time. That's not very random! + +One of the properties of pseudorandom number generators is that +if they start from the same place they will generate +the same sequence of values. The starting place is called +a {\bf seed}; by default, C uses +the same seed every time you run the program. + +While you are debugging, it is often helpful to +see the same sequence over and over. That way, when you make +a change to the program you can compare the output before and +after the change. + +If you want to choose a different seed for the random number +generator, you can use the {\tt srand()} function. It takes +a single argument, which is an integer between 0 and {\tt RAND\_MAX}. + +For many applications, like games, you want to see a different +random sequence every time the program runs. A common way to +do that is to use a library function like {\tt time()} +to generate something reasonably unpredictable +and unrepeatable, like the number of seconds since January +1970, and use that number as a seed. The details +of how to do that depend on your development environment. + +\section{Glossary} + +\begin{description} + +\item[array:] A named collection of values, where all the +values have the same type, and each value is identified by +an index. + +\item[element:] One of the values in a array. The {\tt []} +operator selects elements of a array. + +\item[index:] An integer variable or value used to indicate +an element of a array. + +\item[increment:] Increase the value of a variable by one. +The increment operator in C is {\tt ++}. + +\item[decrement:] Decrease the value of a variable by one. +The decrement operator in C is {\tt -}{\tt -}. + +\item[deterministic:] A program that does the same thing every +time it is run. + +\item[pseudorandom:] A sequence of numbers that appear to be +random, but which are actually the product of a deterministic +computation. + +\item[seed:] A value used to initialize a random number sequence. +Using the same seed should yield the same sequence of values. + +\item[bottom-up design:] A method of program development that +starts by writing small, useful functions and then assembling +them into larger solutions. + +\item[histogram:] A array of integers where each integer +counts the number of values that fall into a certain range. + +\index{array} +\index{element} +\index{index} +\index{deterministic} +\index{pseudorandom} +\index{seed} +\index{histogram} + +\end{description} + +%% +\section{Exercises} +\setcounter{exercisenum}{0} + + +\input{exercises/Exercise_7_english} + + diff --git a/Chapter8_String.tex b/Chapter8_String.tex new file mode 100644 index 0000000..74c19dc --- /dev/null +++ b/Chapter8_String.tex @@ -0,0 +1,949 @@ +% LaTeX source for textbook ``How to think like a computer scientist'' +% Copyright (C) 1999 Allen B. Downey +% Copyright (C) 2009 Thomas Scheffler + + +\selectlanguage{english} +\chapter{Strings and things} +\label{strings} + +\section{Containers for strings} + +We have seen four types of values---characters, integers, +floating-point numbers and strings---but only three types of +variables---{\tt char}, {\tt int} and {\tt double}. So +far we have no way to store a string in a variable or perform +operations on strings. + +This chapter is going to rectify this situation and I can now tell +you that strings in C are stored as an array of characters terminated by the +character {\tt \textbackslash 0}. + +By now this explanation should make sense to you and you probably understand +why we had to learn quite a bit about the working of the language +before we could turn our attention towards string variables. + +\index{} +\index{header file!string.h} +In the previous chapter we have seen that operations on arrays have +only minimal support from the C language itself and we had +to program extra functions by ourselves. +Fortunately things are a little bit easier when we manipulate +these special types of arrays - called strings. There exist a number of +library functions in {\tt string.h} that make string handling a bit easier +than operations on pure arrays. + +Nevertheless string operations in +C are still a lot more cumbersome than their equivalence in other +programing languages and can be a +potential source of errors in your programs, if not handled +carefully. + +\section{String variables} + +You can create a string variable as an array of characters in the following +way: + +\begin{verbatim} + char first[] = "Hello, "; + char second[] = "world."; +\end{verbatim} +% +The first line creates an {\tt string} and assigns it the string value {\tt "Hello."} +In the second line we declare a second string variable. Remember, +the combined declaration and assignment is called initialization. + +Initialisation time is the only time you can assign a value to a string directly (just as with +arrays in general). The initialisation parameters are passed +in the form of a string constant enclosed in quotation marks ({\tt"}\ldots {\tt"}). + +Notice the difference in syntax for the initialisation of arrays and strings. +If you like you can also initialize the string in the normal array syntax, +although this looks a little odd and is not very convenient to type. + +\begin{verbatim} + char first[] = {'H','e','l','l','o',',',' ','\0'}; +\end{verbatim} + +There is no need to supply an array size when you are initialising the +string variable at declaration time. The compiler compute the necessary +array size to store the supplied string. + +Remember what we said about the nature of a string variable. It is an array of +characters \textbf{plus} a marker that shows where our string ends: the +termination character {\tt \textbackslash 0}. + +Normally you do not have to supply this termination character. +The compiler understands our code and insertes it automatically. +However, in the example above, we treated our string exactly +like an array and in this case we have to insert the termination character ourselves. + +When we are using a string variable to store different sting values +during the lifetime of our program we have to declare a size big enough +for the largest sequence of characters that we are going to store. +We also have to make our string variable exactly one character longer than +the text we are going to store, because of the necessary termination character. + +We can output strings in the usual way using the {\tt printf()} function: + +\begin{verbatim} + printf("%s", first); +\end{verbatim} + + + +%% +\section{Extracting characters from a string} + +Strings are called ``strings'' because they are made up of a sequence, +or string, of characters. The first operation we are going to +perform on a string is to extract one of the characters. C +uses an index in square brackets ({\tt [} and {\tt ]}) for this operation: + +\begin{verbatim} + char fruit[] = "banana"; + char letter = fruit[1]; + printf ("%c\n", letter); +\end{verbatim} +% +The expression {\tt fruit[1]} indicates that I want character number 1 +from the string named {\tt fruit}. The result is stored in a {\tt +char} named {\tt letter}. When I output the value of {\tt letter}, I +get a surprise: + +\begin{verbatim} + a +\end{verbatim} +% +{\tt a} is not the first letter of {\tt "banana"}. Unless you are a +computer scientist. For perverse reasons, computer scientists always +start counting from zero. The 0th letter (``zeroeth'') of {\tt +"banana"} is {\tt b}. The 1th letter (``oneth'') is {\tt a} and the +2th (``twoeth'') letter is {\tt n}. + +If you want the zereoth letter of a string, you have to put +zero in the square brackets: + +\begin{verbatim} + char letter = fruit[0]; +\end{verbatim} + +\section{Length} +\index{string!length} +\index{length!string} +\index{} +\index{header file!string.h} + +To find the length of a string (the number of characters this string contains), we can +use the {\tt strlen()} function. The function is called using the string variable +as an argument: + +\begin{verbatim} + #include + int main(void) + { + int length; + char fruit[] = "banana"; + + length = strlen(fruit); + return EXIT_SUCCESS; + } +\end{verbatim} +% +The return value of {\tt strlen()} in this case is 6. We assign this value to the integer + {\tt length} for further use. + +In order to compile this code, you need to include the +header file for the {\tt string.h} library. This library provides a number of +useful functions for operations on strings. +%The type of the {\tt strlen()} is {\tt size_t}, an unsigned value large enough to +%enumerate any object that the system can handle (such as a string). +%for our example we can safely assume that the size of the string object +%in our example will never +%exceed the range of the integer type. +You should familiarize yourself with these functions because they can +help you to solve your programming problems faster. + + +%Notice +%that it is legal to have a variable with the same name as a function. + +To find the last letter of a string, you might be tempted to +try something like + +\begin{verbatim} + int length = strlen(fruit); + char last = fruit[length]; /* WRONG!! */ +\end{verbatim} +% +That won't work. The reason is that {\tt fruit} is still an array and there is no letter +at the array index {\tt fruit[6]} in {\tt "banana"}. Since we started counting at 0, the 6 +letters are numbered from 0 to 5. To get the last character, +you have to subtract 1 from {\tt length}. + +\begin{verbatim} + int length = strlen(fruit); + char last = fruit[length-1]; +\end{verbatim} + +\section{Traversal} +\index{traverse} + +A common thing to do with a string is +start at the beginning, select each character in turn, do +something to it, and continue until the end. This pattern +of processing is called a {\bf traversal}. A natural +way to encode a traversal is with a {\tt while} statement: + +\begin{verbatim} + int index = 0; + while (index < strlen(fruit)) + { + char letter = fruit[index]; + printf("%c\n" , letter); + index = index + 1; + } +\end{verbatim} +% +This loop traverses the string and outputs each letter on +a line by itself. Notice that the condition is +{\tt index < strlen(fruit)}, which means that when +{\tt index} is equal to the length of the string, the +condition is false and the body of the loop is not executed. +The last character we access is the one with the +index {\tt strlen(fruit)-1}. + +\index{loop variable} +\index{variable!loop} +\index{index} + +The name of the loop variable is {\tt index}. An {\bf +index} is a variable or value used to specify one member of an ordered +set, in this case the set of characters in the string. The index +indicates (hence the name) which one you want. The set has to be +ordered so that each letter has an index and each index +refers to a single character. + +As an exercise, write a function that takes a {\tt string} +as an argument and that outputs the letters backwards, all on +one line. + +%\section{A run-time error} +%\index{error!run-time} +%\index{run-time error} + +%Way back in Section~\ref{run-time} I talked about run-time errors, +%which are errors that don't appear until a program has started +%running. + +%So far, you probably haven't seen many run-time errors, because we +%haven't been doing many things that can cause one. Well, now we are. +%If you use the {\tt []} operator and you provide an index that is +%negative or greater than {\tt length-1}, you will get a run-time +%error and a message something like this: + +%\begin{verbatim} +%index out of range: 6, string: banana +%\end{verbatim} +%% +%Try it in your development environment and see how it looks. + + +%% +\section{Finding a {\tt character} in a {\tt string}} +\label{Finding a character in a string} + +If we are looking for a letter in a {\tt string}, we have to search +through the string and detect the position where this +letter occurs in the string. +Here is an implementation of this function: + +\begin{verbatim} + int LocateCharacter(char *s, char c) + { + int i = 0; + while (i < strlen(s)) + { + if (s[i] == c) return i; + i = i + 1; + } + return -1; + } +\end{verbatim} + +We have to pass the {\tt string} +as the first argument, the other argument is the character +we are looking for. Our function returns the index of the first +occurrence of the letter, or {\tt -1} if the letter is not contained +in the string. + + +%% +\section{Pointers and Addresses} +\label{Pointers and Addresses} +\index{pointer} +\index{address} + +When we look at the definition of the {\tt LocateCharacter()} function +you may notice the following construct {\tt char *s} which looks unfamiliar. + +Remember, when we discussed how we had to pass +an array to a function, back in Section~\ref{Passing an array to a function}, +we said that instead of copying the array, we only pass a reference to the function. +Back then, we did not say exactly what this reference was. + + + +C is one of the very few high-level programming languages that +let you directly manipulate objects in the computer memory. +In order to do this direct manipulation, we need to know the location +of the object in memory: it's address. +Adresses can be stored in variables of a special type. +These variables that point to other objects in memory +(such as variables, arrays and strings) +are therefore called {\bf pointer} variables. + +A pointer references the memory location of an object +and can be defined like this: + +\begin{verbatim} + int *i_p; +\end{verbatim} + +This declaration looks similar to our earlier declarations, with one difference: the asterisk +in front of the name. +We have given this pointer the type {\tt int}. The type specification has nothing to do +with the pointer itself, but rather defines which object this pointer is +supposed to reference (in this case an {\tt integer}). +This allows the compiler to do some type checking on, what would +otherwise be, an anonymous reference. + +A pointer all by itself is rather meaningless, we also need an object that +this pointer is referencing: + +\begin{verbatim} + int number = 5; + int *i_p; +\end{verbatim} + +This code-fragment defines an {\tt int} variable and a pointer. We can use + the "address-of" operator~{\tt \&} to assign the memory + location or {\bf address} of our variable to the pointer. + + \begin{verbatim} + i_p = &number; +\end{verbatim} + +%{\tt} +Pointer {\tt i\_p} now references integer variable {\tt number}. +We can verify this using the "content-of" operator~{\tt *}. + + \begin{verbatim} + printf("%i\n", *i_p); +\end{verbatim} + +This prints {\tt 5}, which happens to be the content of the +memory location at our pointer reference. + +With pointers we can directly manipulate memory locations: + + \begin{verbatim} + *i_p = *i_p + 2; + printf("%i\n", number); +\end{verbatim} + +Our variable {\tt number} now has the value {\tt 7} and we begin to +understand how our {\tt LocateCharacter()} function can directly access +the values of string variables through the use of a {\tt char} pointer. + +Pointers are widely used in many C programs and we have only +touched the surface of the topic. They can be immensely useful +and efficient, however they can also be a potential source of +problems when not used appropriately. For this reason not +many programming languages support direct memory manipulation. + + +%If we are looking for a letter in an {\tt string}, we may +%not want to start at the beginning of the string. One way +%to generalize the {\tt find} function is to write a version +%that takes an additional parameter---the index where we should +%start looking. Here is an implementation of this function. + +%\begin{verbatim} +% int Find (char *s, char c, int i) +% { +% while (i < strlen(s)) +% { +% if (s[i] == c) return i; +% i = i + 1; +% } +% return -1; +% } +%\end{verbatim} +% +%We have to pass the {\tt string} +%as the first argument. The other arguments are the character +%we are looking for and the index where we should start. + + + +%% +%\section{Looping and counting} +%\label{loopcount} +%\index{traverse!counting} +%\index{loop!counting} + +%The following program counts the +%number of times the letter {\tt 'a'} appears in a string: + +%\begin{verbatim} +% char fruit[] = "banana"; +% int length = strlen(fruit); +% int count = 0; + +% int index = 0; +% while (index < length) +% { +% if (fruit[index] == 'a') +% { +% count ++; +% } +% index++; +% } +% printf ("%i\n", count); +%\end{verbatim} +%% +%This program demonstrates a common idiom, called a {\bf counter}. The +%variable {\tt count} is initialized to zero and then incremented each +%time we find an {\tt 'a'}. (To {\bf increment} is to increase by one; +%it is the opposite of {\bf decrement}.) When we exit the loop, {\tt count} +%contains the result: the total number of a's. + +%\index{counter} + +%As an exercise, encapsulate this code in a function named +%{\tt CountLetters()}, and generalize it so that it accepts the +%string and the letter as arguments. +%% müssen wir die Länge vorher ermitteln und übergeben? + +%\index{encapsulation} +%\index{generalization} + +%As a second exercise, rewrite this function so that instead +%of traversing the string, it uses the version of +%{\tt find} we wrote in the previous section. + + +%\section{The {\tt strchr} function} +%\index{find} + +% + + +% The {\tt strchr} function is like the opposite of the +%{\tt []} operator. Instead of taking an index and extracting the +%character at that index, {\tt strchr} takes a character and finds the +%index where that character appears. + +%\begin{verbatim} +% char fruit[] = "banana"; +% int index = strchar(fruit,'a')); +%\end{verbatim} +%% +%This example finds the index of the letter {\tt 'a'} in the string. +%In this case, the letter appears three times, so it is not obvious +%what {\tt find} should do. According to the documentation, it returns +%the index of the {\em first} appearance, so the result is 1. If the +%given letter does not appear in the string, {\tt find} returns -1. + +%In addition, there is a +%version of {\tt find} that takes another {\tt string} as +%an argument and that finds the index where the substring +%appears in the string. For example, + +%\begin{verbatim} +% apstring fruit = "banana"; +% int index = fruit.find("nan"); +%\end{verbatim} +%% +%This example returns the value 2. + + + + +%% +%\pagebreak[4] + +\section{String concatenation} + +In Section~\ref{Finding a character in a string} we have seen how we +could implement a search function that finds a {\tt character} in a {\tt string}. + +One useful operation on strings is string {\bf concatenation}. +To concatenate means to +join the two operands end to end. For example: {\tt shoe} +and {\tt maker} becomes {\tt shoemaker}. + +Fortunately, we do not have to program all the necessary functions in C ourselves. +The {\tt string.h} library already provides several functions that we can +invoke on strings. + +We can use the library function {\tt strncat()} to concatenate +strings in C. + +\begin{verbatim} + char fruit[20] = "banana"; + char bakedGood[] = " nut bread"; + strncat(fruit, bakedGood, 10); + printf ("%s\n", fruit); +\end{verbatim} +% +The output of this program is {\tt banana nut bread}. + +When we are using library functions it is important to completely understand +all the necessary arguments and to have a complete understanding +of the working of the function. + +The {\tt strncat()} does not take the two strings, joins them together and +produces a new combined string. It rather copies the content from the second +argument into the first. + +We therefore have to make sure that our first string is long enough to +also hold the second string. We do this by defining the maximum capacity for +string {\tt fruit} to be 19 characters + 1 termination character ({\tt char fruit[20]}). +The third argument of {\tt strncat()} specifies +the number of characters +that will be copied from the second into the first string. + + + +%It is also possible to concatenate a character onto the +%beginning or end of an {\tt string}. In the following example, we +%will use concatenation and character arithmetic to output +%an abecedarian series. + +%``Abecedarian'' refers to a series or list in which the elements +%appear in alphabetical order. For example, in Robert McCloskey's book +%{\em Make Way for Ducklings}, the names of the ducklings are Jack, +%Kack, Lack, Mack, Nack, Ouack, Pack and Quack. Here is a loop that +%outputs these names in order: + +%\begin{verbatim} +% char name[5]; +% char suffix[] = "ack"; + +% char letter = 'J'; +% name[0] = letter; +% name[1] = '\0'; +% +% while (letter <= 'Q') +% { +% /* Wrong, does not work, string gets longer and longer...*/ +% printf("%s\n", strncat (name, suffix, 3)); +% letter++; +% name[0] = letter; +% } +%\end{verbatim} +%% +%The output of this program is: + +%\begin{verbatim} +%Jack +%Kack +%Lack +%Mack +%Nack +%Oack +%Pack +%Qack +%\end{verbatim} +%% +%Of course, that's not quite right because I've misspelled ``Ouack'' +%and ``Quack.'' As an exercise, modify the program to correct +%this error. + +%Again, be careful to use string concatenation only with {\tt apstring}s +%and not with native C strings. Unfortunately, an expression like +%{\tt letter + "ack"} is syntactically legal in C++, although it +%produces a very strange result, at least in my development environment. + +%% +%\section{{\tt string}s are mutable} +%\index{immutable} +%\index{string} + +%You can change the letters in an {\tt string} one at a time +%using the {\tt []} operator on the left side of an assignment. +%For example, + +%\begin{verbatim} +% char greeting[] = "Hello, world!"; +% greeting[0] = 'J'; +% printf ("%s", greeting); +%\end{verbatim} +% +%produces the output {\tt Jello, world!}. + +\section{Assigning new values to {\tt string} variables} +\index{assigning!string} +\index{string} + +So far we have seen how to initialise a string variable +at declaration time. As with arrays in general, it is not +legal to assign values directly to strings, because it is +not possible to assign a value to an entire array. + +\begin{verbatim} + fruit = "orange"; /* Wrong: Cannot assign directly! */ +\end{verbatim} + +In order to assign a new value to an existing string variable we +have to use the {\tt strncpy()} function. +For example, + +\begin{verbatim} + char greeting[15]; + strncpy (greeting, "Hello, world!", 13); +\end{verbatim} + +copies 13 characters from the of the second argument +string to the first argument string. + +This works, but not quite as expected. The {\tt strncpy()} function +copies exactly 13 characters from the second argument string +into the first argument string. And what happens to our +string termination character {\tt \textbackslash 0}? + +%\pagebreak[4] + +It is \textbf{not} copied automatically. We need to change +our copy statement to copy also the invisible 14th character at +the end of the string: + +\begin{verbatim} + strncpy (greeting, "Hello, world!", 14); +\end{verbatim} + +However, if we only copy parts of the second string into the first +we need to explicitly set the n+1th character in the {\tt greeting[15]} +string to {\tt \textbackslash 0} afterwards. + +\begin{verbatim} + strncpy (greeting, "Hello, world!", 5); /*only Hello is copied*/ + greeting[5] = '\0'; +\end{verbatim} + +\vskip 1.5em + +{\bf Attention!} In the last two sections we have used +the {\tt strncpy()} and the {\tt strncat()} function that require you +to explicitly supply the number of characters that will get copied +or attached to the first argument string. + +The {\tt string.h} library also defines the {\tt strcpy()} and +the {\tt strcat()} functions that have no explicit bound on the number +of characters that are copied. + +The usage of these functions is +strongly discouraged! Their use has lead to a vast number +of security problems with C programs. Remember, C does not +check array boundaries and will continue copying characters +into computer memory even past the length of the variable. + + +%% +\section{{\tt string}s are not comparable} +\label{incomparable} +\index{comparison!string} +\index{string} + +All the comparison operators that work on {\tt int}s and +{\tt double}s do work on {\tt strings}. For example, +if you write the following code to determine if two strings are equal: + +\begin{verbatim} + if (word == "banana") /* Wrong! */ +\end{verbatim} + +This test will always fail. + +% +You have to use the {\tt strcmp()} function to compare two strings +with each other. The function returns {\tt 0} if the two strings are +identical, a negative value if the first string is 'alphabetically less' than +the second (would be listed first in a dictionary) or a positive value +if the second string is 'greater'. + +Please notice, this return value is not the standard true/false result, where the +return value {\tt 0} is interpreted as 'false'. + + + +The {\tt strcmp()} function is useful for putting words +in alphabetical order. + +\begin{verbatim} + if (strcmp(word, "banana") < 0) + { + printf( "Your word, %s, comes before banana.\n", word); + } + else if (strcmp(word, "banana") > 0) + { + printf( "Your word, %s, comes after banana.\n", word); + } + else + { + printf ("Yes, we have no bananas!\n"); + } +\end{verbatim} +% +You should be aware, though, that the {\tt strcmp()} function does +not handle upper and lower case letters the same way that people +do. All the upper case letters come before all the lower case +letters. As a result, + +\begin{verbatim} +Your word, Zebra, comes before banana. +\end{verbatim} +% +A common way to address this problem is to convert strings to a +standard format, like all lower-case, before performing the +comparison. The next sections explains how. + +%% +\section{Character classification} + +\index{} +\index{header file!ctype.h} +It is often useful to examine a character and test whether +it is upper or lower case, or whether it is a character or +a digit. C provides a library of functions that perform +this kind of character classification. In order to use these +functions, you have to include the header file {\tt ctype.h}. + +\begin{verbatim} + char letter = 'a'; + if (isalpha(letter)) + { + printf("The character %c is a letter.", letter); + } +\end{verbatim} +% +The return value from {\tt isalpha()} is an integer that is +0 if the argument is not a letter, and some non-zero value +if it is. + +It is legal to use this kind of integer in a conditional, as shown +in the example. The value {\tt 0} is treated as {\tt false}, and +all non-zero values are treated as {\tt true}. + +%Technically, this sort of thing should not be allowed---integers are +%not the same thing as boolean values. Nevertheless, the C habit of +%converting automatically between types can be useful. + +Other character classification functions include {\tt isdigit()}, which +identifies the digits 0 through 9, and {\tt isspace()}, which identifies +all kinds of ``white'' space, including spaces, tabs, newlines, and a +few others. There are also {\tt isupper()} and {\tt islower()}, which +distinguish upper and lower case letters. + +Finally, there are two functions that convert letters from one +case to the other, called {\tt toupper()} and {\tt tolower()}. Both take +a single character as an argument and return a (possibly +converted) character. + +\begin{verbatim} + char letter = 'a'; + letter = toupper (letter); + printf("%c\n", letter); +\end{verbatim} +% +The output of this code is {\tt A}. + +As an exercise, use the character classification and conversion +library to write functions named {\tt StringToUpper()} and +{\tt StringToLower()} that take a single string as +a parameter, and that modify the string by converting all the +letters to upper or lower case. The return type should be +{\tt void}. + +%%% +%\section{Other {\tt string} functions} + +%This chapter does not cover all the {\tt apstring} functions. +%Two additional ones, {\tt c\_str} and {\tt substr}, are covered +%in Section~\ref{finput} and Section~\ref{parsing}. + +\section{Getting user input} +\label{input} +\index{input!keyboard} + +The programs we have written so far are pretty predictable; +they do the same thing every time they run. Most of the time, +though, we want programs that take input from the user and +respond accordingly. + +There are many ways to get input, including keyboard +input, mouse movements and button clicks, as well as more exotic +mechanisms like voice control and retinal scanning. In this +text we will consider only keyboard input. + +\index{scanf()} +\index{printf()} + +In the header file {\tt stdio.h}, +C defines a function named {\tt scanf()} that handles input in +much the same way that {\tt printf()} handles output. We can use the following code to get an +integer value from the user: + +\begin{verbatim} + int x; + scanf("%i", &x); +\end{verbatim} +% +The {\tt scanf()} function causes the program to stop executing and +wait for the user to type something. If the user types a valid +integer, the program converts it into an integer value and +stores it in {\tt x}. + +If the user types something other than an integer, +C doesn't report an error, or anything sensible like that. +Instead, the {\tt scanf()} function returns and leaves the value in {\tt x} unchanged. + +Fortunately, there is a way to check and see if an input +statement succeeds. The {\tt scanf()} function returns the number +of items that have been successfully read. +This number will be {\tt 1} when the last input +statement succeeded. If not, we know that some previous operation +failed, and also that the next operation will fail. + +Getting input from the user might look like this: + +\begin{verbatim} + int main (void) + { + int success, x; + + /* prompt the user for input */ + printf ("Enter an integer: \n"); + + /* get input */ + success = scanf("%i", &x); + + /* check and see if the input statement succeeded */ + if (success == 1) + { + /* print the value we got from the user */ + printf ("Your input: %i\n", x); + return EXIT_SUCCESS; + } + printf("That was not an integer.\n"); + return EXIT_FAILURE; + } +\end{verbatim} +% +There is another potential pitfall connected with the {\tt scanf()} function. +Your program code might want to insist that the user types a valid integer, because +this value is needed later on. In this case you might want to +repeat the input statement in order to get a valid user input: + + \begin{verbatim} + if (success != 1) + { + while (success != 1) + { + printf("That was not a number. Please try again:\n"); + success = scanf("%i", &x); + } + } +\end{verbatim} + +\index{input!flushing the buffer} +\index{input buffer!flushing the buffer} +Unfortunately this code leads into an endless loop. You probably ask yourself, why? +The input from the keyboard is delivered to your program by the operating system, in +something called an input buffer. A successful read operation automatically empties this buffer. +However, if the {\tt scanf()} function fails, like in our example, the buffer does not get emptied +and the next {\tt scanf()} operation re-reads the old value - you see the problem? + +We need to empty the input buffer, before we can attempt to read the next input from the +user. Since there is no standard way to do this, we will introduce our own code that +reads and empties the buffer using the {\tt getchar()} function. It run through a {\tt while}-loop +until there are no more characters left in the buffer (notice the construction of this loop, where all +the operations are executed in the test condition): +\begin{verbatim} + char ch; /* helper variable stores discarded chars*/ + while (success != 1) + { + printf("That isn't a number. Please try again:\n"); + /* now we empty the input buffer*/ + while ((ch = getchar()) != '\n' && ch != EOF); + success = scanf("%i", &x); + } + +\end{verbatim} + + +The {\tt scanf()} function can also be used to input a {\tt string}: + +\begin{verbatim} + char name[80]; + + printf ("What is your name?"); + scanf ("%s", name); + printf ("%s", name); +\end{verbatim} +% +Again, we have to make sure our string variable is large enough +to contain the complete user input. Notice the difference in the +argument of the {\tt scanf()} function when we are reading +an {\tt integer} or a {\tt string}. The function requires a +pointer to the variable where the input value will be stored. +If we are reading an {\tt integer} we need to use the address operator {\tt \&} +with the variable name. In the case of a {\tt string} we simply provide the +variable name. + +Also notice, that the {\tt scanf()} function only takes the first word of +the input, and leaves the rest for the next input statement. +So, if you run this program and type your full name, it +will only output your first name. + + + +\section{Glossary} + +\begin{description} + +\item[index:] A variable or value used to select one of the +members of an ordered set, like a character from a string. + +\item[traverse:] To iterate through all the elements of a set +performing a similar operation on each. + +\item[counter:] A variable used to count something, usually +initialized to zero and then incremented. + +\item[concatenate:] To join two operands end-to-end. + +\item[pointer:] A reference to an object in computer memory. + +\item[address:] The exact storage location of objects in memory. + +\index{index} +\index{traverse} +\index{counter} +\index{increment} +\index{decrement} +\index{concatenate} +\index{pointer} +\index{address} + + +\end{description} + +\section{Exercises} +\setcounter{exercisenum}{0} + + +\input{exercises/Exercise_8_english} + diff --git a/Chapter9_Struct.tex b/Chapter9_Struct.tex new file mode 100644 index 0000000..59a9cac --- /dev/null +++ b/Chapter9_Struct.tex @@ -0,0 +1,550 @@ +% LaTeX source for textbook ``How to think like a computer scientist'' +% Copyright (C) 1999 Allen B. Downey +% Copyright (C) 2009 Thomas Scheffler + + +\chapter{Structures} +\label{structs} +\index{struct} + +\section{Compound values} + +Most of the data types we have been working with represent a single +value---an integer, a floating-point number, a character value. +Strings are different in the sense that they are made up of smaller +pieces, the characters. Thus, strings are an example of a +{\bf compound} type. + +Depending on what we are doing, we may want to treat a compound type +as a single thing (or object), or we may want to access its parts (or +member variables). This ambiguity is useful. + +It is also useful to be able to create your own compound values. +C provides a mechanism for doing that: {\bf structures}. + +\section{{\tt Point} objects} +\index{Point} +\index{struct!Point} + +As a simple example of a compound structure, consider the concept of a +mathematical point. At one level, a point is two numbers +(coordinates) that we treat collectively as a single object. In +mathematical notation, points are often written in parentheses, with a +comma separating the coordinates. For example, $(0, 0)$ indicates the +origin, and $(x, y)$ indicates the point $x$ units to the right and +$y$ units up from the origin. + +A natural way to represent a point in C is with two {\tt double}s. +The question, then, is how to group these two values into +a compound object, or structure. The answer is a {\tt struct} +definition: + +\begin{verbatim} + typedef struct + { + double x; + double y; + } Point_t; +\end{verbatim} +% +{\tt struct} definitions appear outside of any function definition, +usually at the beginning of the program (after the {\tt include} +statements). + +This definition indicates that there are two elements in this +structure, named {\tt x} and {\tt y}. These elements are called +the {\bf members} or {\bf fields} of a structure. +%, for reasons I will explain a little later. + +It is a common error to leave off the semi-colon at the end of a +structure definition. It might seem odd to put a semi-colon after +curly-brackets, but you'll get used to it. + +Once you have defined the new structure, you can create variables +with that type: + +\begin{verbatim} + Point_t blank; + blank.x = 3.0; + blank.y = 4.0; +\end{verbatim} +% +The first line is a conventional variable declaration: {\tt blank} has +type {\tt Point\_t}. The next two lines initialize the fields of the +structure. The ``dot notation'' used here is called the {\bf field selection +operator} and allows to access the structure fields. + +\index{declaration} +\index{statement!declaration} +\index{reference} +\index{state diagram} +\index{state} + +The result of these assignments is shown in the following +state diagram: + +\vspace{0.1in} +\centerline{\epsfig{figure=figs/point.pdf, width=3.0cm}} +\vspace{0.1in} + +As usual, the name of the variable {\tt blank} appears outside the box +and its value appears inside the box. In this case, that value is +a compound object with two named member variables. + +\section{Accessing member variables} +\index{struct!member variable} + +You can read the values of an member variable using the same syntax we +used to write them: + +\begin{verbatim} + double x = blank.x; +\end{verbatim} +% +The expression {\tt blank.x} means ``go to the object named {\tt +blank} and get the value of {\tt x}.'' In this case we assign that +value to a local variable named {\tt x}. Notice that there is no +conflict between the local variable named {\tt x} and the member +variable named {\tt x}. The purpose of dot notation is to identify +{\em which} variable you are referring to unambiguously. + +You can use dot notation as part of any C expression, so the +following are legal. + +\begin{verbatim} + printf ("%0.1f, %0.1f\n", blank.x, blank.y); + double distance = blank.x * blank.x + blank.y * blank.y; +\end{verbatim} +% +The first line outputs {\tt 3, 4}; the second line calculates +the value 25. + +\section{Operations on structures} +\index{struct!operations} +\index{typecasting} + +Most of the operators we have been using on other types, like +mathematical operators ( {\tt +}, {\tt \%}, etc.) and comparison +operators ({\tt ==}, {\tt >}, etc.), do not work on structures. +%Actually, it is possible to define the meaning of these operators +%for the new type, but we won't do that in this book. + +On the other hand, the assignment operator {\em does} work for +structures. It can be used in two ways: to initialize the member +variables of a structure or to copy the member variables from one +structure to another. An initialization looks like this: + +\begin{verbatim} + Point_t blank = { 3.0, 4.0 }; +\end{verbatim} +% +The values in squiggly braces get assigned to the member variables of +the structure one by one, in order. So in this case, {\tt x} +gets the first value and {\tt y} gets the second. + +Unfortunately, this syntax can be used only in an initialization, +not in an assignment statement. So the following is illegal: + +\begin{verbatim} + Point_t blank; + blank = { 3.0, 4.0 }; /* WRONG !! */ +\end{verbatim} +% +You might wonder why this perfectly reasonable statement should +be illegal; I'm not sure, but I think the problem is that the compiler +doesn't know what type the right hand side should be. You must specify +the type of the assignment by adding a typecast: + +\begin{verbatim} + Point_t blank; + blank = (Point_t){ 3.0, 4.0 }; +\end{verbatim} +% +That works. + +It is legal to assign one structure to +another. For example: + +\begin{verbatim} + Point_t p1 = { 3.0, 4.0 }; + Point_t p2 = p1; + printf ("%f, %f\n", p2.x, p2.y); +\end{verbatim} +% +The output of this program is {\tt 3, 4}. + +%% +\section{Structures as parameters} +\label{Structures as parameters} +\index{parameter} +\index{struct!as parameter} + +You can pass structures as parameters in the usual way. For +example, + +\begin{verbatim} + void PrintPoint (Point_t point) + { + printf ("(%0.1f, %0.1f)\n", point.x, point.y); + } +\end{verbatim} +% +{\tt PrintPoint()} takes a point as an argument and outputs it in +the standard format. If you call {\tt PrintPoint(blank)}, +it will output {\tt (3.0, 4.0)}. + +As a second example, we can rewrite the {\tt ComputeDistance()} function from +Section~\ref{distance} so that it takes two {\tt Point}s as parameters +instead of four {\tt double}s. + +\begin{verbatim} + double ComputeDistance (Point_t p1, Point_t p2) + { + double dx = p2.x - p1.x; + double dy = p2.y - p1.y; + return sqrt (dx*dx + dy*dy); + } +\end{verbatim} + +\section{Call by value} +\label{Call by value} +\index{parameter passing} +\index{call by value} + +When you pass a structure as an argument, remember that the +argument and the parameter are not the same variable. Instead, +there are two variables (one in the caller and one in the +callee) that have the same value, at least initially. For +example, when we call {\tt PrintPoint()}, the stack diagram +looks like this: + +\vspace{0.1in} +\centerline{\epsfig{figure=figs/stack_point2.pdf, width=6cm}} +\vspace{0.1in} +% +If {\tt PrintPoint()} happened to change one of the member variables +of {\tt point}, it would have no effect on {\tt blank}. Of course, there +is no reason for {\tt PrintPoint()} to modify its parameter, so this +isolation between the two functions is appropriate. + +This kind of parameter-passing is called ``pass by value'' +because it is the value of the structure (or other type) that +gets passed to the function. + +\section{Call by reference} +\label{Call by reference} +\index{parameter passing} +\index{call by reference} +\index{reference} + +An alternative parameter-passing mechanism that is available +in C is called ``pass by reference.'' +By now we already know that C uses pointers as references. +This mechanism makes +it possible to pass a structure to a procedure and modify it directly. + +For example, you can reflect a point around the 45-degree line by +swapping the two coordinates. The most obvious (but incorrect) way to +write a {\tt ReflectPoint()} function is something like this: + +\begin{verbatim} + void ReflectPoint (Point_t point) /* Does not work! */ + { + double temp = point.x; + point.x = point.y; + point.y = temp; + } +\end{verbatim} +% +This won't work, because the changes we make in {\tt ReflectPoint()} +will have no effect on the caller. + +Instead, we have to specify that we want to pass the parameter by +reference. +Our function now has a struct pointer argument {\tt Point\_t~*ptr}. + + +\begin{verbatim} + void ReflectPoint (Point_t *ptr) + { + double temp = ptr->x; + ptr->x = ptr->y; + ptr->y = temp; + } +\end{verbatim} +When we are accessing the struct member variables through a pointer +we can no longer use the "field-selection-operator" ({\tt .}). Instead we need to use +the "pointing-to" operator ({\tt ->}). + +% +We pass a reference of our struct parameter by adding the "address-of" operator ({\tt \&}) to the +structure variable when we call the function: + +\begin{verbatim} + PrintPoint (blank); + ReflectPoint (&blank); + PrintPoint (blank); +\end{verbatim} +% +The output of this program is as expected: + +\begin{verbatim} + (3.0, 4.0) + (4.0, 3.0) +\end{verbatim} +% +Here's how we would draw a stack diagram for this program: + +\vspace{0.1in} +\centerline{\epsfig{figure=figs/stack_point3.pdf, width=6.5cm}} +\vspace{0.1in} +% +The parameter {\tt ptr} is a reference to the structure named {\tt +blank}. The usual representation for a reference is a dot with an +arrow that points to whatever the reference refers to. + +The important thing to see in this diagram is that any changes that +{\tt ReflectPoint()} makes through {\tt ptr} will also affect {\tt blank}. + +Passing structures by reference is more versatile than passing by +value, because the callee can modify the structure. It is also +faster, because the system does not have to copy the whole +structure. On the other hand, it is less safe, since it is harder to +keep track of what gets modified where. Nevertheless, in C +programs, almost all structures are passed by reference almost all the +time. In this book I will follow that convention. + + +\section{Rectangles} +\index{Rectangle} +\index{struct!Rectangle} + +Now let's say that we want to create a structure to represent +a rectangle. The question is, what information do I have to +provide in order to specify a rectangle? To keep things simple +let's assume that the rectangle will be oriented vertically or +horizontally, never at an angle. + +There are a few possibilities: I could specify the center of +the rectangle (two coordinates) and its size (width and height), +or I could specify one of the corners and the size, or I +could specify two opposing corners. + +The most common choice in existing programs is to specify the +upper left corner of the rectangle and the size. To do that +in C, we will define a structure that contains a {\tt Point\_t} +and two doubles. + +\begin{verbatim} + typedef struct + { + Point_t corner; + double width, height; + } Rectangle_t; +\end{verbatim} +% +Notice that one structure can contain another. In fact, this +sort of thing is quite common. Of course, this means that in +order to create a {\tt Rectangle\_t}, we have to create a {\tt Point\_t} +first: + +\begin{verbatim} + Point_t corner = { 0.0, 0.0 }; + Rectangle_t box = { corner, 100.0, 200.0 }; +\end{verbatim} +% +This code creates a new {\tt Rectangle\_t} structure and initializes the +member variables. The figure shows the effect of this assignment. + +\vspace{0.1in} +\centerline{\epsfig{figure=figs/rectangle.pdf, width=6cm}} +\vspace{0.1in} +% +We can access the {\tt width} and {\tt height} in the usual way: + +\begin{verbatim} + box.width += 50.0; + printf("%f\n", box.width); +\end{verbatim} +% +In order to access the member variables of {\tt corner}, we can use a +temporary variable: + +\begin{verbatim} + Point_t temp = box.corner; + double x = temp.x; +\end{verbatim} +% +Alternatively, we can compose the two statements: + +\index{composition} + +\begin{verbatim} + double x = box.corner.x; +\end{verbatim} +% +It makes the most sense to read this statement from right to +left: ``Extract {\tt x} from the {\tt corner} of the {\tt box}, +and assign it to the local variable {\tt x}.'' + +While we are on the subject of composition, I should point +out that you can, in fact, create the {\tt Point} and the +{\tt Rectangle} at the same time: + +\begin{verbatim} + Rectangle_t box = { { 0.0, 0.0 }, 100.0, 200.0 }; +\end{verbatim} +% +The innermost squiggly braces are the coordinates of the +corner point; together they make up the first of the three +values that go into the new {\tt Rectangle}. This statement +is an example of {\bf nested structure}. + +\index{nested structure} + + +\section{Structures as return types} +\index{struct!as return type} +\index{return} +\index{statement!return} + +You can write functions that return structures. For example, +{\tt FindCenter()} has a {\tt Rectangle\_t} parameter and +returns a {\tt Point\_t} that contains the coordinates of the +center of the rectangle: + +\begin{verbatim} + Point_t FindCenter (Rectangle_t box) + { + double x = box.corner.x + box.width/2; + double y = box.corner.y + box.height/2; + Point_t result = {x, y}; + return result; + } +\end{verbatim} +% +To call this function, we have to pass a {\tt Rectangle\_t} as an argument +(notice that it is being passed by value), and assign the +return value to a {\tt Point\_t} variable: + +\begin{verbatim} + Rectangle_t box = { {0.0, 0.0}, 100, 200 }; + Point_t center = FindCenter (box); + PrintPoint (center); +\end{verbatim} +% +The output of this program is {\tt (50, 100)}. + +We could have passed the structure as a reference to the +function. In this case our function would look like this: + +\begin{verbatim} + Point_t FindCenter (Rectangle_t *box) + { + double x = box->corner.x + box->width/2; + double y = box->corner.y + box->height/2; + Point_t result = {x, y}; + return result; + } +\end{verbatim} +Notice, how we had to change the access to the members of the +structure, since {\tt box} is now a pointer. +We would also have to change the function call for {\tt FindCenter()}: + +\begin{verbatim} + Point_t center = FindCenter (&box); +\end{verbatim} + +\section {Passing other types by reference} +\index{parameter passing} +\index{call by reference} +\index{reference} + +It's not just structures that can be passed by reference. +All the other types we've seen can, too. For example, to swap +two integers, we could write something like: + +\begin{verbatim} + void Swap (int *x, int *y) + { + int temp = *x; + *x = *y; + *y = temp; + } +\end{verbatim} +% +We would call this function in the usual way: + +\begin{verbatim} + int i = 7; + int j = 9; + printf (" i=%i, j=%i\n", i, j); + Swap (&i, &j); + printf (" i=%i, j=%i\n", i, j); +\end{verbatim} +% +The output of this program shows that the variable +values have been swapped. Draw a stack +diagram for this program to convince yourself this is true. +If the parameters {\tt x} and {\tt y} were declared as +regular integer variables (without the {\tt \*}s), {\tt Swap()} would +not work. It would modify {\tt x} and {\tt y} and have no +effect on {\tt i} and {\tt j}. + +When people start passing things like integers by reference, +they often try to use an expression +as a reference argument. For example: + +\begin{verbatim} + int i = 7; + int j = 9; + Swap (&i, &j+1); /* WRONG!! */ +\end{verbatim} +% +Presumably the programmer wanted to increase the value of {\tt j} by {\tt 1} +before it is passed to the function. +This does not work as expected, because the expression {\tt j+1} now +is interpreted a pointer value and in now pointing to a memory +location beyond the variable {\tt j}. +It is a little tricky to figure out exactly +what kinds of expressions make sense to be passed by reference. For now +a good rule of thumb is that reference arguments have to be +variables. + + +\section{Glossary} + +\begin{description} + +\item[structure:] A collection of data grouped together and +treated as a single object. + +\item[member variable:] One of the named pieces of data that make up +a structure. + +\item[reference:] A value that indicates or refers to a variable +or structure. In a state diagram, a reference appears as an arrow. + +\item[pass by value:] A method of parameter-passing in which the +value provided as an argument is copied into the corresponding +parameter, but the parameter and the argument occupy distinct +locations. + +\item[pass by reference:] A method of parameter-passing in which +the parameter is a reference to the argument variable. Changes +to the parameter also affect the argument variable. + +\index{structure} +\index{member variable} +\index{reference} +\index{pass by value} +\index{pass by reference} + +\end{description} + +\section{Exercises} +\setcounter{exercisenum}{0} + +\input{exercises/Exercise_9_english} + + diff --git a/Main.tex b/Main.tex new file mode 100644 index 0000000..525d53e --- /dev/null +++ b/Main.tex @@ -0,0 +1,238 @@ +% LaTeX source for textbook ``How to think like a computer scientist'' +% Copyright (C) 1999 Allen B. Downey +% Copyright (C) 2009 Thomas Scheffler + + +\documentclass[a4paper]{book} +\usepackage[ngerman,english]{babel} +\usepackage[latin1]{inputenc} +\usepackage[T1]{fontenc} +\usepackage{lmodern} +\usepackage{epsfig} +\usepackage{makeidx} +\usepackage{url} +\usepackage{fancyhdr} +\usepackage{multicol} +\usepackage[hidelinks]{hyperref} +\usepackage{longtable} +\usepackage{ifthen} +\usepackage{boxedminipage} +\usepackage{todonotes} + +% conditional compilation of the document for different languages + +%\newboolean{German} +%\setboolean{German}{false} + +% the exercise environment + +\newcounter{exercisenum} + +% by default, the exercise number includes the chapter number +% this way, an exercise label is a complete, unique exercise id + +\renewcommand{\theexercisenum}{{\thechapter}.\arabic{exercisenum}} + +% Standard font size for exercise/problem text + +\newenvironment{exercisesize}{\begin{small}}{\end{small}} + +\newcommand{\exerciseheader}[2]{ + + \begin{exercisesize} + + % Use alphabetic chars for subparts of exercises, + % and roman numerals for subparts of them. + + \def\theenumi{\alph{enumi}} + \def\labelenumi{\theenumi.} + \def\theenumii{\roman{enumii}} + \def\labelenumii{\theenumii.} + {\bf Exercise {#1}{#2}}\hspace{0.1in} +} + +\newcommand{\startexercise}[1]{% + \refstepcounter{exercisenum} + \exerciseheader{\theexercisenum}{#1} +} + +\newcommand{\stopexercise}{% + {\hfill} + \end{exercisesize} +} + +\newcommand{\normaldif}{} + +\newcommand{\bigdif}{\dag{}} + +\newcommand{\verybigdif}{\ddag{}} + +\newenvironment{exercise}{\startexercise{\normaldif{}}}{\stopexercise} + +\newenvironment{hardexercise}{\startexercise{\bigdif{}}}{\stopexercise} + +%% end of the exercise environment + + +%%------------------------------------------------------------ +% formatting commands + +\sloppy +\setlength{\topmargin}{0.125in} +\setlength{\oddsidemargin}{0.875in} +\setlength{\evensidemargin}{0.875in} + +\setlength{\headsep}{3ex} +\setlength{\textheight}{8in} + +\setlength{\parindent}{0.0in} +\setlength{\parskip}{1.7ex plus 0.5ex minus 0.5ex} +\renewcommand{\baselinestretch}{1.02} + +% see LaTeX Companion page 62 +\setlength{\topsep}{-0.0\parskip} +\setlength{\partopsep}{-0.5\parskip} +\setlength{\itemindent}{0.0in} +\setlength{\listparindent}{0.0in} + +% see LaTeX Companion page 26 +% these are copied from /usr/local/teTeX/share/texmf/tex/latex/base/book.cls +% all I changed is afterskip + +\makeatletter +\renewcommand{\section}{\@startsection + {section} {1} {0mm}% + {-3.5ex \@plus -1ex \@minus -.2ex}% + {0.7ex \@plus.2ex}% + {\normalfont\Large\bfseries}} +\renewcommand\subsection{\@startsection {subsection}{2}{0mm}% + {-3.25ex\@plus -1ex \@minus -.2ex}% + {0.3ex \@plus .2ex}% + {\normalfont\large\bfseries}} +\renewcommand\subsubsection{\@startsection {subsubsection}{3}{0mm}% + {-3.25ex\@plus -1ex \@minus -.2ex}% + {0.3ex \@plus .2ex}% + {\normalfont\normalsize\bfseries}} + +\makeatother + +\newcommand{\beforeverb}{\vspace{0.6\parskip}} +\newcommand{\afterverb}{\vspace{0.6\parskip}} + +\newcommand{\adjustpage}[1]{\enlargethispage{#1\baselineskip}} +\newcommand{\clearemptydoublepage}{\newpage{\pagestyle{empty}\cleardoublepage}} +\newcommand{\blankpage}{\pagestyle{empty}\vspace*{1in}\newpage} + +\newcommand{\beforefig}{\vspace{1.3\parskip}} +\newcommand{\afterfig}{\vspace{-0.2\parskip}} +\newcommand{\myfig}[1]{ + \beforefig + \centerline{\epsfig{#1,scale=0.8}} + \afterfig +} + +\newcommand{\beforechapter}{ +% \clearemptydoublepage + \cleardoublepage + \setcounter{exercisenum}{0} +} + +\pagestyle{fancyplain} + +\renewcommand{\chaptermark}[1]{\markboth{#1}{}} +\renewcommand{\sectionmark}[1]{\markright{\thesection\ #1}{}} + +\lhead[\fancyplain{}{\bfseries\thepage}]% + {\fancyplain{}{\bfseries\rightmark}} +\rhead[\fancyplain{}{\bfseries\leftmark}]% + {\fancyplain{}{\bfseries\thepage}} +\cfoot{} + +% turn off the rule under the header +%\setlength{\headrulewidth}{0pt} + +% the following is a brute-force way to prevent the headers +% from getting transformed into all-caps +\renewcommand\MakeUppercase{} + + +\sloppy +\setlength{\topmargin}{0.75in} +\setlength{\headsep}{0.5in} +\setlength{\oddsidemargin}{1.0in} +\setlength{\evensidemargin}{.95in} +\makeindex + + +%%----------------------------------------------------------- +% beginning of the document + +\begin{document} + +\thispagestyle{empty} + +\begin{flushright} +\vspace*{2.5in} + +{\huge How to Think Like a Computer Scientist} + +\vspace{0.25in} + +{\LARGE C Version} + +\vspace{1in} + +{\Large Thomas Scheffler} + +{based on previous work by Allen B. Downey} + +\vspace{1in} + +{\Large Version 1.10} + +{\small June 27th, 2019} +\vfill + +\end{flushright} + + + +Copyright (C) 1999 Allen B. Downey\\ +Copyright (C) 2009 Thomas Scheffler + +\vspace{0.25in} + +Permission is granted to copy, distribute, transmit and adapt this +work under the Creative Commons Attribution-NonCommercial-ShareAlike 4.0 +International License: \url{https://creativecommons.org/licenses/by-nc/4.0/}. + +If you are interested in distributing a commercial version of this +work, please contact the author(s). + +The \LaTeX\ source and code for this book is available from: \\ +\url{https://github.com/tscheffl/ThinkC} + +\frontmatter +\tableofcontents + +\mainmatter +\include{Chapter1} +\include{Chapter2} +\include{Chapter3} +\include{Chapter4} +\include{Chapter5} +\include{Chapter6_Iteration} +\include{Chapter7_Array} +\include{Chapter8_String} +\include{Chapter9_Struct} + + +\appendix +\include{Append1} +\include{ASCII} +\printindex + +\end{document} + + + diff --git a/Readme.md b/Readme.md index 7e44ab9..50f1a76 100644 --- a/Readme.md +++ b/Readme.md @@ -1,3 +1,4 @@ # ThinkC -Text and code for Think C by Thomas Scheffler, based on previous work by Allen Downey: https://greenteapress.com/wp/ \ No newline at end of file +Text and code for **Think C** by Thomas Scheffler, +based on previous work by Allen Downey: https://greenteapress.com/wp/ \ No newline at end of file diff --git a/exercises/Exercise_1_english.tex b/exercises/Exercise_1_english.tex new file mode 100644 index 0000000..6300755 --- /dev/null +++ b/exercises/Exercise_1_english.tex @@ -0,0 +1,98 @@ +% LaTeX source for textbook ``How to think like a computer scientist'' +% Copyright (C) 1999 Allen B. Downey +% Copyright (C) 2009 Thomas Scheffler + +\begin{exercise} + +Computer scientists have the annoying habit of using common +English words to mean something different from their common +English meaning. For example, in English, a statement and +a comment are pretty much the same thing, but when we are +talking about a program, they are very different. + +The glossary at the end of each chapter is intended to highlight +words and phrases that have special meanings in computer science. +When you see familiar words, don't assume that you know what +they mean! + +\begin{enumerate} + +\item In computer jargon, what's the difference between a statement +and a comment? + +\item What does it mean to say that a program is portable? + +\item What is an executable? + +\end{enumerate} + +\end{exercise} + +\begin{exercise} + +Before you do anything else, find out how to compile and run a C +program in your environment. Some environments provide sample programs +similar to the example in Section~\ref{hello}. + +\begin{enumerate} + +\item Type in the ``Hello World'' program, then compile and run it. + +\item Add a second print statement that prints a second message after +the ``Hello World.''. Something witty like, ``How are you?'' +Compile and run the program again. + +\item Add a comment line to the program (anywhere) and recompile +it. Run the program again. The new comment should not affect the +execution of the program. + +\end{enumerate} + +This exercise may seem trivial, but it is the starting place for many +of the programs we will work with. In order to debug with confidence, +you have to have confidence in your programming environment. In some +environments, it is easy to lose track of which program is executing, +and you might find yourself trying to debug one program while you are +accidentally executing another. Adding (and changing) print statements +is a simple way to establish the connection between the program you +are looking at and the output when the program runs. + +\end{exercise} + + +\begin{exercise} + +It is a good idea to commit as many errors as you can think of, +so that you see what error messages the compiler produces. +Sometimes the compiler will tell you exactly what is wrong, and all +you have to do is fix it. Sometimes, though, the compiler will produce +wildly misleading messages. You will develop a sense for when you can +trust the compiler and when you have to figure things out yourself. + +\begin {enumerate} + +\item Remove the closing curly-bracket (\}). + +\item Remove the opening curly-bracket (\{). + +\item Remove the {\tt int} before {\tt main}. + +\item Instead of {\tt main}, write {\tt mian}. + +\item Remove the closing {\tt */} from a comment. + +\item Replace {\tt printf} with {\tt pintf}. + +% Example of a logical error: +% +%\item Replace {\tt printf} with {\tt print}. This one is +%tricky because it is a logical error, not a syntax error. +%The statement {\tt System.out.print} is legal, but it may or may +%not do what you expect. + +\item Delete one of the parentheses: {\tt (} or {\tt )}. Add an extra one. + +\item Delete the semicolon after the {\tt return} statement. + +\end {enumerate} +\end{exercise} \ No newline at end of file diff --git a/exercises/Exercise_2_english.tex b/exercises/Exercise_2_english.tex new file mode 100644 index 0000000..d5af538 --- /dev/null +++ b/exercises/Exercise_2_english.tex @@ -0,0 +1,91 @@ +% LaTeX source for textbook ``How to think like a computer scientist'' +% Copyright (C) 1999 Allen B. Downey +% Copyright (C) 2009 Thomas Scheffler + +\begin{exercise} +\label{ex.date} + +\begin{enumerate} + +\item Create a new program named {\tt MyDate.c}. Copy or +type in something like the "Hello, World" program and make +sure you can compile and run it. + +\item Following the example in Section~\ref{output variables}, write a program +that creates variables named {\tt day}, {\tt month} +and {\tt year} +What type is each variable? + +Assign values to those variables that represent today's date. + +\item Print the value of each variable on a line by itself. This is +an intermediate step that is useful for checking that everything is +working so far. + +\item Modify the program so that it prints the date in standard +American form: {\tt {\tt mm/dd/yyyy}}. + +\item Modify the program again so that the total output is: + +\begin{verbatim} +American format: +3/18/2009 +European format: +18.3.2009 +\end{verbatim} + +\end{enumerate} + +The point of this exercise is to use the output function {\tt printf} to display +values with different types, and to +practice developing programs gradually by adding a few statements +at a time. + + + +\end{exercise} + + +\begin{exercise} + +\begin{enumerate} + +\item Create a new program called {\tt MyTime.c}. From now +on, I won't remind you to start with a small, working program, +but you should. + +\item Following the example in Section~\ref{operators}, create variables +named {\tt hour}, {\tt minute} and {\tt second}, and assign +them values that are roughly the current time. Use a 24-hour +clock, so that at 2pm the value of {\tt hour} is 14. + +\item Make the program calculate and print the number of +seconds since midnight. + +\item Make the program calculate and print the number of +seconds remaining in the day. + +\item Make the program calculate and print the percentage of +the day that has passed. + +\item Change the values of {\tt hour}, {\tt minute} and {\tt second} +to reflect the current time (I assume that some time has elapsed), and +check to make sure that the program works correctly with different +values. + +\end{enumerate} + +The point of this exercise is to use some of the arithmetic +operations, and to start thinking about compound entities like the +time of day that are represented with multiple values. Also, +you might run into problems computing percentages with {\tt ints}, +which is the motivation for floating point numbers in the next +chapter. + +HINT: you may want to use additional variables to hold values +temporarily during the computation. Variables like this, that +are used in a computation but never printed, are sometimes called +intermediate or temporary variables. + +\end{exercise} + diff --git a/exercises/Exercise_3_english.tex b/exercises/Exercise_3_english.tex new file mode 100644 index 0000000..75a9cb1 --- /dev/null +++ b/exercises/Exercise_3_english.tex @@ -0,0 +1,164 @@ +% LaTeX source for textbook ``How to think like a computer scientist'' +% Copyright (C) 1999 Allen B. Downey +% Copyright (C) 2009 Thomas Scheffler + + +\begin{exercise} + +The point of this exercise is to practice reading code and to +make sure that you understand the flow of execution through +a program with multiple functions. + +\begin{enumerate} + +\item What is the output of the following program? Be precise +about where there are spaces and where there are newlines. + +HINT: Start by describing in words what {\tt Ping()} and +{\tt Baffle()} do when they are invoked. + +\begin{verbatim} +#include +#include + + void Ping () + { + printf (".\n"); + } + + void Baffle () + { + printf ("wug"); + Ping (); + } + + void Zoop () + { + Baffle (); + printf ("You wugga "); + Baffle (); + } + + int main (void) + { + printf ("No, I "); + Zoop (); + printf ("I "); + Baffle (); + return EXIT_SUCCESS; + } +\end{verbatim} + + +\item Draw a stack diagram that shows the state of the program +the first time {\tt Ping()} is invoked. + +\end{enumerate} + +\end{exercise} + +%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%% + +\begin{exercise} +The point of this exercise is to make sure you understand how +to write and invoke functions that take parameters. + +\begin{enumerate} + +\item Write the first line of a function named {\tt Zool()} that +takes three parameters: an {\tt int} and two {\tt char}. + +\item Write a line of code that invokes {\tt Zool()}, passing +as arguments the value {\tt 11}, the letter {\tt a}, and the letter {\tt z}. +\end{enumerate} + + +\end{exercise} + + +%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%% + +\begin{exercise} + +The purpose of this exercise is to take code from a previous exercise +and encapsulate it in a function that takes parameters. You should +start with a working solution to exercise +%~\ref{ex.date}. + +\begin{enumerate} + +\item Write a function called {\tt PrintDateAmerican()} +that takes the day, month and year as parameters and that +prints them in American format. + +\item Test your function by invoking it from {\tt main()} and passing +appropriate arguments. The output should look something like this +(except that the date might be different): +% +\begin{verbatim} +3/29/2009 +\end{verbatim} +% +\item Once you have debugged {\tt PrintDateAmerican()}, write another +function called {\tt PrintDateEuropean()} that prints the date in +European format. + +\end{enumerate} + +%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%% +\end{exercise} + +\begin{exercise} +\label{ex.multadd} + +Many computations can be expressed concisely using the ``multadd'' +operation, which takes three operands and computes {\tt a*b + c}. Some +processors even provide a hardware implementation of this operation for +floating-point numbers. + +\begin{enumerate} + +\item Create a new program called {\tt Multadd.c}. + +\item Write a function called {\tt Multadd()} that takes three {\tt doubles} +as parameters and that prints their multadditionization. + +\item Write a {\tt main()} function that tests {\tt Multadd()} by invoking it with a +few simple parameters, like {\tt 1.0, 2.0, 3.0}, and then prints +the result, which should be {\tt 5.0}. + +\item Also in {\tt main()}, use {\tt Multadd()} to compute the +following value: +% +\begin{eqnarray*} +& \sin \frac{\pi}{4} + \frac{\cos \frac{\pi}{4}}{2} & +%\\ +%\\ +%& \log 10 + \log 20 & +\end{eqnarray*} +% +\item Write a function called {\tt Yikes()} that takes a +double as a parameter and that uses {\tt Multadd()} to calculate +and print +% +\begin{eqnarray*} +x e^{-x} + \sqrt{1 - e^{-x}} +\end{eqnarray*} +% +HINT: the Math function for raising $e$ to a power is {\tt double exp(double x);}. + +\end{enumerate} + +In the last part, you get a chance to write a function that invokes +a function you wrote. Whenever you do that, it is a good idea to +test the first function carefully before you start working on the +second. Otherwise, you might find yourself debugging two functions +at the same time, which can be very difficult. + +One of the purposes of this exercise is to practice pattern-matching: +the ability to recognize a specific problem as an instance of a +general category of problems. + + + +\end{exercise} \ No newline at end of file diff --git a/exercises/Exercise_4_english.tex b/exercises/Exercise_4_english.tex new file mode 100644 index 0000000..1a7368e --- /dev/null +++ b/exercises/Exercise_4_english.tex @@ -0,0 +1,204 @@ +% LaTeX source for textbook ``How to think like a computer scientist'' +% Copyright (C) 1999 Allen B. Downey +% Copyright (C) 2009 Thomas Scheffler + + +\begin{exercise} +This exercise reviews the flow of execution through a program +with multiple methods. Read the following code and answer the +questions below. + +\begin{verbatim} + + #include + #include + + void Zippo (int quince, int flag); + + void Baffle (int output) + { + printf ("%i\n",output); + Zippo (12, -5); + } + + void Zippo (int quince, int flag) + { + if (flag < 0) + { + printf ("%i zoop\n", quince); + } + else + { + printf ("rattle "); + Baffle (quince); + printf ("boo-wa-ha-ha\n"); + } + } + + int main (void) + { + Zippo (5, 13); + return EXIT_SUCCESS; + } + + +\end{verbatim} + +\begin{enumerate} + +\item Write the number {\tt 1} next to the first {\em statement} +of this program that will be executed. Be careful to distinguish +things that are statements from things that are not. + +\item Write the number {\tt 2} next to the second statement, and so on +until the end of the program. If a statement is executed more than +once, it might end up with more than one number next to it. + +\item What is the value of the parameter {\tt blimp} when {\tt baffle()} +gets invoked? + +\item What is the output of this program? + +\end{enumerate} +\end{exercise} + + +\begin{exercise} +The first verse of the song ``99 Bottles of Beer'' is: + +\begin{quote} +99 bottles of beer on the wall, +99 bottles of beer, +ya' take one down, ya' pass it around, +98 bottles of beer on the wall. +\end{quote} + +Subsequent verses are identical except that the number +of bottles gets smaller by one in each verse, until the +last verse: + +\begin{quote} +No bottles of beer on the wall, +no bottles of beer, +ya' can't take one down, ya' can't pass it around, +'cause there are no more bottles of beer on the wall! +\end{quote} +% +And then the song (finally) ends. + +Write a program that prints the entire lyrics of +``99 Bottles of Beer.'' Your program should include a +recursive method that does the hard part, but you also +might want to write additional methods to separate the major +functions of the program. + +As you are developing your code, you will probably +want to test it with a small number of verses, like +``3 Bottles of Beer.'' + +The purpose of this exercise is to take a problem and break it +into smaller problems, and to solve the smaller problems by writing +simple, easily-debugged methods. +\end{exercise} + + +\begin{exercise} +You can use the {\tt getchar()} function in C to +get character input from the user through the keyboard. +This function stops the execution of the program and waits +for the input from the user. + +The {\tt getchar()} function has the type {\tt int} and does +not require an argument. It returns the ASCII-Code (cf. Appendix~\ref{ASCII-Table}) +of the key that has been pressed on the keyboard. +\begin{enumerate} +\item Write a program, that asks the user +to input a digit between 0 and 9. + +\item Test the input from the user and display an error message +if the returned value is not a digit. The program should then +be terminated. +If the test is successful, the program should print the +input value on the computer screen. +\end{enumerate} + + +\end{exercise} + +% Kapitel 5 (Return) +%Schreiben Sie dazu eine Funktion {\tt AsciiToNumber()} welche ein +%{\tt int} als Typ und als Argument besitzt. Übergeben Sie der Funktion +%den eingelesenen Wert und + + + + +% String--Ausgabe! + +%\begin{exercise} +%Lesen Sie das folgende Programm. Notieren Sie die Ausgabe die während der +%Abarbeitung des Programms erzeugt wird. + +%\begin{verbatim} +% void Zoop (String fred, int bob) +% { +% printf ("%s\n", fred); +% if (bob == 5) +% { +% ping ("not "); +% } +% else +% { +% printf ("!\n"); +% } +% } + +% int main (void) +% { +% int bizz = 5; +% int buzz = 2; +% zoop ("just for", bizz); +% clink (2*buzz); +% } + +% void clink (int fork) +% { +% printf ("It's "); +% zoop ("breakfast ", fork) ; +% } + +% void ping (String strangStrung) +% { +% printf ("any %smore \n", strangStrung); +% } +%} +%\end{verbatim} +%\end{exercise} + +\begin{exercise} +Fermat's Last Theorem says that there are no integers +$a$, $b$, and $c$ such that + +\[a^n + b^n = c^n \] +% +except in the case when $n=2$. + +Write a function named {\tt checkFermat()} that takes four +integers as parameters---{\tt a}, {\tt b}, {\tt c} and {\tt n}---and +that checks to see if Fermat's theorem holds. If +$n$ is greater than 2 and it turns out to be true that +$a^n + b^n = c^n$, +the program should print ``Holy smokes, Fermat was wrong!'' +Otherwise the program should print ``No, that doesn't work.'' + +You should assume that there is a function named {\tt raiseToPow()} +that takes two integers as arguments and that raises the +first argument to the power of the second. For example: + +\begin{verbatim} + int x = raiseToPow (2, 3); +\end{verbatim} +% +would assign the value {\tt 8} to {\tt x}, because $2^3 = 8$. +\end{exercise} + diff --git a/exercises/Exercise_5_english.tex b/exercises/Exercise_5_english.tex new file mode 100644 index 0000000..635dd53 --- /dev/null +++ b/exercises/Exercise_5_english.tex @@ -0,0 +1,241 @@ +% LaTeX source for textbook ``How to think like a computer scientist'' +% Copyright (C) 1999 Allen B. Downey +% Copyright (C) 2009 Thomas Scheffler + + +\begin{exercise} +If you are given three sticks, you may or may not be able to arrange +them in a triangle. For example, if one of the sticks is 12 inches +long and the other two are one inch long, it is clear that you will +not be able to get the short sticks to meet in the middle. For any +three lengths, there is a simple test to see if it is possible to form +a triangle: + +\begin{quotation} +``If any of the three lengths is greater than the sum of the other two, +then you cannot form a triangle. Otherwise, you can.'' +\end{quotation} + +Write a function named {\tt IsTriangle()} that it takes three integers as +arguments, and that returns either {\tt TRUE} or {\tt FALSE}, +depending on whether you can or cannot form a triangle from sticks +with the given lengths. + + +The point of this exercise is to use conditional statements to +write a function that returns a value. +\end{exercise} + + +%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%% + + +%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%% + +\begin{exercise} +What is the output of the following program? + +The purpose of this exercise is to make sure you understand logical operators and the flow of execution through fruitful methods. + +\begin{verbatim} +#define TRUE 1 +#define FALSE 0 + + + short IsHoopy (int x) + { + short hoopyFlag; + if (x%2 == 0) + { + hoopyFlag = TRUE; + } + else + { + hoopyFlag = FALSE; + } + return hoopyFlag; + } + + short IsFrabjuous (int x) + { + short frabjuousFlag; + if (x > 0) + { + frabjuousFlag = TRUE; + } + else + { + frabjuousFlag = FALSE; + } + return frabjuousFlag; + } + + int main (void) + { + short flag1 = IsHoopy (202); + short flag2 = IsFrabjuous (202); + printf ("%i\n", flag1); + printf ("%i\n", flag2); + if (flag1 && flag2) + { + printf ("ping!\n"); + } + if (flag1 || flag2) + { + printf ("pong!\n"); + } + return EXIT_SUCCESS; + } + +\end{verbatim} +\end{exercise} + + + +\begin{exercise} +\begin{enumerate} + + +\item Create a new program called {\tt Sum.c}, +and type in the following two functions. + +\begin{verbatim} + int FunctionOne (int m, int n) + { + if (m == n) + { + return n; + } + else + { + return m + FunctionOne (m+1, n); + } + } + + int FunctionTwo (int m, int n) + { + if (m == n) + { + return n; + } + else + { + return n * FunctionTwo (m, n-1); + } + } +\end{verbatim} +% +\item Write a few lines in {\tt main()} to test these functions. +Invoke them a couple of times, with a few different values, +and see what you get. By some combination of testing and +examination of the code, figure out what these functions do, +and give them more meaningful names. Add comments that +describe their function abstractly. + +\item Add a {\tt prinf} statement to the beginning of both +functions so that they print their arguments each time they are +invoked. This is a useful technique for debugging recursive +programs, since it demonstrates the flow of execution. + +\end{enumerate} +\end{exercise} + +\begin{exercise} +\label{ex.power} +Write a recursive function called {\tt Power()} that +takes a double {\tt x} and an integer {\tt n} and that +returns $x^n$. + +Hint: a recursive definition of this +operation is {\tt Power (x, n) = x * Power (x, n-1)}. +Also, remember that anything raised to the zeroeth power +is 1. +\end{exercise} + + +\begin{exercise} + +\label{gcd} +(This exercise is based on page 44 of Ableson and Sussman's +{\em Structure and Interpretation of Computer Programs}.) + +The following algorithm is known as Euclid's Algorithm because +it appears in Euclid's {\em Elements} (Book 7, ca. 300 B.C.). +It may be the oldest nontrivial algorithm. + +The algorithm is based on the observation that, if $r$ is the +remainder when $a$ is divided by $b$, then the common divisors +of $a$ and $b$ are the same as the common divisors of $b$ and $r$. +Thus we can use the equation + +\[ gcd (a, b) = gcd (b, r) \] + +to successively reduce the problem of computing a GCD to the +problem of computing the GCD of smaller and smaller pairs of integers. +For example, + +\[ gcd (36, 20) = gcd (20, 16) = gcd (16, 4) = gcd (4, 0) = 4\] + +implies that the GCD of 36 and 20 is 4. It can be shown +that for any two starting numbers, this repeated reduction eventually +produces a pair where the second number is 0. Then the GCD is the +other number in the pair. + +Write a function called {\tt gcd} that takes two integer parameters and +that uses Euclid's algorithm to compute and return the greatest +common divisor of the two numbers. +\end{exercise} + + + + +% + +\begin{exercise} +The distance between two points $(x_1, y_1)$ and $(x_2, y_2)$ +is + +\[Distance = \sqrt{(x_2 - x_1)^2 + (y_2 - y_1)^2} \] + +Please write a function named {\tt Distance()} that takes four +doubles as parameters---{\tt x1}, {\tt y1}, {\tt x2} and {\tt +y2}---and that prints the distance between the points. + +You should assume that there is a function named {\tt SumSquares()} +that calculates and returns the sum of the squares of its arguments. +For example: + +\begin{verbatim} + double x = SumSquares (3.0, 4.0); +\end{verbatim} +% +would assign the value {\tt 25.0} to {\tt x}. + +The point of this exercise is to write a new function that uses an +existing one. You should write only one function: {\tt Distance()}. You +should not write {\tt SumSquares()} or {\tt main()} and you should not +invoke {\tt Distance()}. +\end{exercise} + + +\begin{exercise} +The point of this exercise is to practice the syntax of fruitful +functions. + +\begin{enumerate} + +\item Use your existing solution to Exercise~\ref{ex.multadd} and make sure +you can still compile and run it. + +\item Transform {\tt Multadd()} into a fruitful function, so +that instead of printing a result, it returns it. + +\item Everywhere in the program that {\tt Multadd()} gets +invoked, change the invocation so that it stores the +result in a variable and/or prints the result. + +\item Transform {\tt Yikes()} in the same way. + +\end{enumerate} +\end{exercise} + diff --git a/exercises/Exercise_6_english.tex b/exercises/Exercise_6_english.tex new file mode 100644 index 0000000..a22659e --- /dev/null +++ b/exercises/Exercise_6_english.tex @@ -0,0 +1,109 @@ +% LaTeX source for textbook ``How to think like a computer scientist'' +% Copyright (C) 1999 Allen B. Downey +% Copyright (C) 2009 Thomas Scheffler + +%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%% + +\begin{exercise}\label{infloop} +%changed the condition on the loop so that it will terminate +%(was this *supposed* to be an infinite loop?) +\begin{verbatim} + void Loop(int n) + { + int i = n; + while (i > 1) + { + printf ("%i\n",i); + if (i%2 == 0) + { + i = i/2; + } + else + { + i = i+1; + } + } + } + + int main (void) + { + Loop(10); + return EXIT_SUCCESS; + } +\end{verbatim} +% +\begin{enumerate} + +\item Draw a table that shows the value of the variables {\tt i} and {\tt n} during the execution of the program. +The table should contain one column for each variable and one line for each iteration. + + +\item What is the output of this program? + +\end{enumerate} +\end{exercise} + +%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%% + + + +\begin{exercise} +In Exercise~\ref{ex.power} we wrote a recursive version of {\tt +Power()}, which takes a double {\tt x} and an integer {\tt n} and +returns $x^n$. Now write an iterative function to perform the same +calculation. +\end{exercise} + +%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%% + +\begin{exercise} +Let's say you are given a number, $a$, and you want to find +its square root. One way to do that is to start with a very +rough guess about the answer, $x_0$, and then improve +the guess using the following formula: + +\begin{displaymath} +x_1 = (x_0 + a/x_0) / 2 +\end{displaymath} + +For example, if we want to find the square root of 9, and +we start with $x_0 = 6$, then $x_1 = (6 + 9/6) /2 = 15/4 = 3.75$, +which is closer. + +We can repeat the procedure, using $x_1$ to calculate $x_2$, +and so on. In this case, $x_2 = 3.075$ and $x_3 = 3.00091$. +So that is converging very quickly on the right answer (which +is 3). + +Write a function called {\tt SquareRoot} that takes a {\tt double} +as a parameter and that returns an approximation of the square +root of the parameter, using this algorithm. You may not use +the {\tt sqrt()} function from the {\tt math.h} library. + +As your initial guess, you should use $a/2$. Your function should +iterate until it gets two consecutive estimates that differ by +less than 0.0001; in other words, until the absolute value of +$x_n - x_{n-1}$ is less than 0.0001. You can use the built-in +{\tt fabs()} function from the {\tt math.h} library to calculate the absolute value. +\end{exercise} + +%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%% + + +\begin{exercise} +One way to evaluate $e^{-x^2}$ is to use the infinite series expansion + +\begin{displaymath} +e^{-x^2} = 1 - 2x + 3x^2/2! - 4x^3/3! + 5x^4/4! - ... +\end{displaymath} + +In other words, we need to add up a series of terms where the $i$th +term is equal to $(-1)^i(i+1) x^i / i!$. Write a function named {\tt Gauss()} +that takes {\tt x} and {\tt n} as arguments and that returns the sum +of the first {\tt n} terms of the series. You should not use {\tt +factorial()} or {\tt pow()}. + +\end{exercise} + +%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%% + diff --git a/exercises/Exercise_7_english.tex b/exercises/Exercise_7_english.tex new file mode 100644 index 0000000..995af24 --- /dev/null +++ b/exercises/Exercise_7_english.tex @@ -0,0 +1,71 @@ +% LaTeX source for textbook ``How to think like a computer scientist'' +% Copyright (C) 1999 Allen B. Downey +% Copyright (C) 2009 Thomas Scheffler + +%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%% +\begin{exercise} + +A friend of yours shows you the following method and +explains that if {\tt number} is any two-digit number, the program +will output the number backwards. He claims that if {\tt number} is +17, the method will output {\tt 71}. + +Is he right? If not, explain what the program actually does and +modify it so that it does the right thing. + +\begin{verbatim} + #include + #include + + int main (void) + { + int number = 71; + int lastDigit = number%10; + int firstDigit = number/10; + printf("%i",lastDigit + firstDigit); + return EXIT_SUCCESS; + } + +\end{verbatim} + +\end{exercise} + + +%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%% +\begin{exercise} +Write a function that takes an array of integers, the length of the array and an integer named +{\tt target} as arguments. + +The function should search through the provided array and should return the first index where +{\tt target} appears in the array, if it does. If {\tt target} is not in the array the function should +return an invalid index value to indicate an error condition (e.g. -1). +\end{exercise} + +%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%% + +\begin{exercise} + +One not-very-efficient way to sort the elements of an array +is to find the largest element and swap it with the first +element, then find the second-largest element and swap it with +the second, and so on. + +\begin{enumerate} + +\item Write a function called {\tt IndexOfMaxInRange()} that +takes an array of integers, finds the +largest element in the given range, and returns its {\em index}. + +\item Write a function called {\tt SwapElement()} that takes an +array of integers and two indices, and that swaps the elements +at the given indices. + +\item Write a function called {\tt SortArray()} that takes an array of +integers and that uses {\tt IndexOfMaxInRange()} and {\tt SwapElement()} +to sort the array from largest to smallest. + +\end{enumerate} +\end{exercise} + + +%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%% diff --git a/exercises/Exercise_8_english.tex b/exercises/Exercise_8_english.tex new file mode 100644 index 0000000..573c41d --- /dev/null +++ b/exercises/Exercise_8_english.tex @@ -0,0 +1,122 @@ +% LaTeX source for textbook ``How to think like a computer scientist'' +% Copyright (C) 1999 Allen B. Downey +% Copyright (C) 2009 Thomas Scheffler + +%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%% +\begin{exercise} +A word is said to be ``abecedarian'' if the letters in the +word appear in alphabetical order. For example, the following +are all 6-letter English abecedarian words. + +\begin {quote} +abdest, acknow, acorsy, adempt, adipsy, agnosy, befist, behint, +beknow, bijoux, biopsy, cestuy, chintz, deflux, dehors, dehort, +deinos, diluvy, dimpsy +\end{quote} + +\begin{enumerate} + +\item Describe an algorithm for checking whether a given word (String) +is abecedarian, assuming that the word contains only lower-case +letters. Your algorithm can be iterative or recursive. + +\item Implement your algorithm in a function called {\tt IsAbecedarian()}. + +\end{enumerate} +\end{exercise} + +%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%% + + +\begin{exercise} +Write a function called {\tt LetterHist()} that takes a String as a +parameter and that returns a histogram of the letters in the String. +The zeroeth element of the histogram should contain the number of a's +in the String (upper and lower case); the 25th element should contain +the number of z's. +Your solution should only traverse the String once. +\end{exercise} + + +%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%% + + +\begin{exercise} +A word is said to be a ``doubloon'' if every letter that appears in the +word appears exactly twice. For example, the following are all the +doubloons I found in my dictionary. + +\begin {quote} +Abba, Anna, appall, appearer, appeases, arraigning, beriberi, +bilabial, boob, Caucasus, coco, Dada, deed, Emmett, Hannah, +horseshoer, intestines, Isis, mama, Mimi, murmur, noon, Otto, papa, +peep, reappear, redder, sees, Shanghaiings, Toto +\end{quote} + +Write a function called {\tt IsDoubloon()} that returns {\tt TRUE} +if the given word is a doubloon and {\tt FALSE} otherwise. +\end{exercise} + + + + +%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%% + +\begin{exercise} + +The Captain Crunch decoder ring works by taking each letter in a +string and adding 13 to it. For example, 'a' becomes 'n' and 'b' +becomes 'o'. The letters ``wrap around'' at the end, so 'z' becomes +'m'. + +\begin{enumerate} +\item Write a function that takes a String and that returns a new String +containing the encoded version. You should assume that the String +contains upper and lower case letters, and spaces, but no other +punctuation. Lower case letters should be transformed into other lower +case letters; upper into upper. You should not encode the spaces. + +\item Generalize the Captain Crunch method so that instead of adding +13 to the letters, it adds any given amount. Now you should be able +to encode things by adding 13 and decode them by adding -13. Try it. + +\end{enumerate} +\end{exercise} + + +%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%% + +\begin{exercise} +In Scrabble each player has a set of tiles with letters on them, and +the object of the game is to use those letters to spell words. The +scoring system is complicated, but as a rough guide longer words are +often worth more than shorter words. + +Imagine you are given your set of tiles as a String, like {\tt +"qijibo"} and you are given another String to test, like {\tt "jib"}. +Write a function called {\tt TestWord()} that takes these two Strings and +returns true if the set of tiles can be used to spell the word. You +might have more than one tile with the same letter, but you can only +use each tile once. +\end{exercise} + + + +%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%% + + + +\begin{exercise} +In real Scrabble, there are some blank tiles that can be used +as wild cards; that is, a blank tile can be used to represent +any letter. + +Think of an algorithm for {\tt TestWord()} that deals with wild +cards. Don't get bogged down in details of implementation like +how to represent wild cards. Just describe the algorithm, using +English, pseudocode, or C. +\end{exercise} + + + + diff --git a/exercises/Exercise_9_english.tex b/exercises/Exercise_9_english.tex new file mode 100644 index 0000000..36d6066 --- /dev/null +++ b/exercises/Exercise_9_english.tex @@ -0,0 +1,103 @@ +% LaTeX source for textbook ``How to think like a computer scientist'' +% Copyright (C) 1999 Allen B. Downey +% Copyright (C) 2009 Thomas Scheffler + +%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%% + +\begin{exercise} + +Section~\ref{Structures as parameters} defines the function {\tt PrintPoint()}. +The argument of this function is passed along as a value (\emph{call-by-value}). + +\begin{enumerate} +\item Change the definition of this function, so that it only passes a reference to +the structure to the function for printing (\emph{call-by-reference}). + +\item Test the new function with different values and document the results. +\end{enumerate} + + +\end{exercise} + + +%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%% + +\begin{exercise} + +Write a program, that defines a struct \texttt{Person\_t}. +This struct should contain two members. The first member should be a string +of sufficient length, to contain the name of a person. The second member should +be an integer value containing the persons age. + +\begin{enumerate} +\item Define two struct variables \texttt{person1} and \texttt{person2}.\\ +Initialize the two struct variables with suitable values. The first person +should be called Betsy. Betsy should be 42 years old.\\ +The second person should be named after yourself and should also be as old as yourself. + + +\item Write a function \texttt{PrintPerson()}. The function should take a struct variable of type +\texttt{Person\_t} as an argument and print the name of the person and the corresponding age. +\item Write a function \texttt{HappyBirthday()}. The function should increase the age of the +corresponding person by one year and print out a birthday greeting.\\ +\textbf{Hint: }You need to passes a reference to the structure to the function (\emph{call-by-reference}). +If your function uses \emph{call-by-value}, the age only changes in the local copy of the struct and +the changes you have made are lost, once the function terminates. Try it out, if you do not believe me! +\end{enumerate} + + +\end{exercise} + + + + +%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%% + +\begin{exercise} + +Most computer games can capture our interest only when their actions are +non-predictable, otherwise they become boring quickly. +Section~\ref{Random numbers} tells us how to generate random numbers in +in C. + + +Write a simple game, where the computer chooses an arbitrary number in +the range between 1 and 20. You will then be asked to guess the +number chosen by the Computer. + +To give you a hint the computer should answer your guess in the following +way: in case your guess was lower than the number of the computer, the +output should be: \emph{My number is larger!} \\ +If you guess was higher than +the number of the computer, the output should read: \\ +\emph{My number is smaller!} + +It is necessary to seed the random number generator when you start your program +(cf. Section~\ref{Random seeds}. +You could use the {\tt time()} function for this. It returns the actual time measured +in seconds since 1971. + +\begin{verbatim} + srand(time(NULL)); /*Initialisation of the random number generator*/ +\end{verbatim} + +When you found the right answer, the computer should congratulate you. The +program should also display the number of tries that where needed in order +to guess the number. + +The program should also keep the a `High-Score', that gets updated once +our number of trials is lower than any previous try. +The High-Score (the number of minimal guesses) should be stored in a + {\tt struct}, together with the name of the player. + +The \texttt{High-Score()} function should ask for your name and store it, when +your current number of tries is lower than the previous High-Score value. + +The program then gives you the chance to play again or stop the game by pressing + 'q' on the keyboard. + + + +\end{exercise} + + diff --git a/figs/Compiler.pdf b/figs/Compiler.pdf new file mode 100644 index 0000000000000000000000000000000000000000..8e32a3e4f39b0d0a835fb3bc825c67af1996b5b8 GIT binary patch literal 29160 zcmeFYWpEzLvL!0ABulc$VrFKREJll&nVFfHEVh`LEsL3%nVFfvVtA6_?tSjrH|E4l zych4sM90^iRb5^ERaRDZ=IYgiQv8CHv{dvEgk9Sg+lTp=8Dm{N5DYjpIF>pl5bW$Y z)MEM;hIU3cjIUKPIMjm1W_J2EuSYX&JAHnAT}wTE98OLMTRR(lZF2}Gz+9z%8~k3l z<{QPSD0VUNZ?<2E#Y1?@W<+oMp zXPD2kZ;23|?@;_5Bru52Va{%;Dc}zf!Wk>dtB5AX~n`>>1~y4Jf3{=%unt-v1(eC zliHE$*uINn9iZ~@4&&v?#N&ObkGnIsCM34t zVr%%>ja8jXVYk}#!oBW-Tqk=K2})8l3|oq9N0#CaKl7 z`&+ryu!4s;l>?~ES~0Pt0$fJ1IZO&Sh*9Mq`2tQ5KeUpOfAB@d3kE2K487qReesUXERLH)-=(Ta^7{E`;cFDR&#)W z!$d0Zd>TT!2KwEIvlNGEj)h*Mt-HgolZ5?Se+@VdDCDk8b$1hd5#?H3_f@u4co^Vn z!Bn7guJ9V0M)XIg)P`U^x5mhf?@*N~^jLQw`XoP2>a525p=Mz?<#q*ZGU~i8Pq0rN zKjLMx(g;8iv*NU)R`{hyiAVdjBEt4VdGBOF)Jbu!X@6L_rb9z4Q|A`wqoMGX#&3uM zh43?Fro|U>kZB+D(3We_#_N-6iTcbNH-O_A^A4E=g&YnD!hH>gw_1P3uL`zUwm^oO z0V4_udF|OgLKHkKgR;K?8MPgh7NYJWDz;u+%~!^G+%?Y$#6>7H8H8tr_MCnZzoEu0 z1ij8g1p{@mVxUl;ZY{03;GAUR0f&jT1#m>KM1U{{B>*eEjQ6ufQ1Z$CX?iK|>X6A{ zt_1rtq%11P15>%^nvb|N#Zpp7*mqt`T7k*2uW94jn%@6-2_FG zjO`>xf@m{ISZ@HvE&(trHD_8H#va+AEDjo3EjtPu<7Awh0N(#w8bVWBA9z2YN<51< zTM&@cogSFT%r=V!#TpK&$ivuT#uOY1;CC|#WKx)J5fDrI&*9W(siMQQRQGDx0VC)6bR8(G-PkSqk$KvO(YECU*c~jI9$d zh^=(xDYq$Pnc)wQ5W^y!NnuR&X)k%%`py3Z9*%!?yEm8jO2ZL|Z{-lzX4~ zgaEvs2J`mcamAP+pDO<y7moXd3R`f&CemA`%9dW637=F zWMWJ}Rem%e*<$X@2Cq!A#vM0a-0VyeU!S}=z0JEH;^*dQTjapxRa#y4C5n5TgAfF! z-g@7r#v`u?r%3cspaBE=!QjyQsU=8))wtJHjM`@JMId{ebKgyf<@zlQ1!`}|5_p^a z06{Z7VR5Bt8QZOxDZMslM|ARqKfqvz6L{bD9Vt%I$h<}4;FiV?d^ZYt;En^W#OKKB zf!i`8kPnbwSQEow!@TP*04tEK0Opdv^Oyh}*Gm}XihZiGS(64T6kZo56B@Dl%QQG+ zAri520c1yH9<>4bk_-P1g{}DEDw89_P}Rz@yB|D!AmeTq4MA8nCW5_OQjMm>DSF(P zjl8c86uz{ytU{L0{YO6z%HFalp?qc`+J@L_+{g;yYsMeNFTuy1@wMXC5(A4t7k=xz zp-ZEaopwu{;`z*Bt`brHu7&s0>s*@o=faT%n@k}7|qmu=18iCn0wEPpw0WqLHbfFw&5QsHhG zMaiWeb6sp75xxsedLmBypn$Xz0(x!eOCR0(!)&c!nyC3+E6fZ+oe}<1yii)`qDcDD zrv;ryAww@v=Q}ek-*{Gv^bg-cNc!vI2(cQf_=j~}quWCGl=ntKF-t^Qp;Mha3HE@l zVySjQZ|-4{`53!5<^h&rlXX0p5)>CI+d~z5JwvU>Epvl zR}&U_ap!37v4$FqCEX{<(xIbo3(t1;P6=Jqi>qDhLEqN^a>KdQHDO9b@6TU2&o0y; z^eyy$M zboFgNwPVmS&bV zvR2x<`Z#Y<8J{gZ4lV85KY)0Z>2O%y#J6f%9Oj=QC+BOB_WDAUQc& z99p{nYNI5nW1_G7tC_GlEd=YYj)cu$ulO~>*Pi|w!rSRTL--vT(!P!R_1?d9_@_T= zS$iG3pIZGnCLC%-W4+ffl8FU}`m?^Vp^+U93)AcPUUg|>W%(9NLfF~ZziR()gP4Kvz5}f;j=Wivb1=cr`HbuAt;6Tdr*3u(hlKE1IzzpTMEjbe9+x` zEFvY+{DFNh;9Q2}DCbh6sJ^Ot#&PG+UY*f7D$+`xRg?Y`D_3LVV?K{-IdYQM4T`wZ zU@dYOI)^?rgEr-=27|>_O!JsuwVUgB-MH*E@5h;oV}VUU$$7~Cj~lAHD9^_32=1nn$EX8e?Hc{XUEu2k%vk8>la%GFojou;^#Zo&bz;{H9_S-D;n=3a_ad~OSj;&gkljr7z6o;-QO$TpGgUzjL(k% zI>Z7s*SoH>I3MU<1}JgzAMA+_d%H@DCA)jGJ-!foo%%~2e5A>_CrtxTNu?!<1zge> zY>FP)v+K#nk;85tNkC6MUxJ-b6&Zf5ckr`;StFyzdw~_cmC~^A?169r3+?`gmHejR zw^d8a!th@!`E5P@_m%wn;qkw-lK<~a{6{nK=lT1$nV@@n{{FX_p!*pb;807vhB4GU zZ;*|}TQKt5#$|+FLyUiTX#R`w`pc^Zq06H@N3-@rG>%LzOjG9YHQSLkiq;@5=T;@D zMpv1lRm@K#@l-}f>kS{{DcNMcBz?+h1_8G_E_)#&)-liz(rhu>j3|2^r;#gidr*}?n<$=^UYYxy-ZIWNn zm!{+duJBA}M3P1@`CRJ*>xG<|>vEW-DlZqk?fZ&GFnjEws#|3!y56OMXh=f_v#tqw zl`>ZQi-E0vUmV9c)8&6o4LfiHabmVA(!)vt3&3twHqL3dO_hy(tX!-0e(6yf!q`7j zmn}hY5&qP^`u(hG&obz<48y0?*S7m!%7gDYY$8Pjup|K@fLk?6Fp*f>@~;x7Q$9BJ z86L|K5?vrXZpT9eRPxU2{IABk|j!?I4a zNWL4|vC@~eT6~3EJAg%VvJ+U|4uM8oIW24f4yw9L3^j-aHiP5$QF< zr?w3(!#U1bMSO+PZf=)9!VvlDY`0xEvi{}-#8rUdQCuwY)g27 zG&x;TRy&)Z#7brvj~%yp0evU!JR?tf5yVcIzolMg<~TZ>Y?)hYbG1#9W&dEitF)m! zt|rL>y!w;?FdQ<+41C$Al)ZUooVBX60>$>;{4{#DFvx!nLDVww#F+L{eYKsR1}iiY zehD+>y~I11_e<_^zKvSR?MZvXA1>F)?#Z^9xNuvD5sIfJlT_+;$Xz?uiDSVz-PMHA z54P%L#_YRkmA~{;S}-|Vf9-OVJ;HBDv~3A&F;`?C@dz+_(R8|TKeg^f<0nTN@7u&; z4shHCK7~(pU*-w7hX zkt*oPwE+qR;^_(?K>GUV%)Y;XmFj7i<`>vr4mEv$TEcj_lJwN8ygI*IJ3DW9>OR{5 zAob`2(qX3r=*5t!gm7}$t_J^cugJ4H!9r=$iP)BDO~_99a84|tZ#Um zU8QE%`8(u|{R#0zTbXFD$$b+;T4ij1 ziWmS5LZar-E>WggFr5Gb>Pheg5CC{g7i*IZbjTg6Q5t|#p5fLPkYHh*Jh<5e|p6t#wRD_-lVHO2y_Nt#*I}m&%m|X@0gEtio5QWwU3@>^s;1wJIKd;ZQz;VD- zpMi|IK`MAS=KvshXy*VOd`+wXro3IoKqP#atU%R36x%*nK|*;6aYF>Oi_!qDcpHQJ zoWUYy@f1ZO<-jEJ&cLFpfIIW?NU~oa$7BFaFrgj1fQV;58 zpmONCj)L}#jtI?kf^LF>81fF20W7`uolmaLba|c<@i#7q_e^lfVU%48S`k{RW%1>} zbJ|CrFra(eP&Y8FJnB%?=qwn&gVe&zhBkT~c79kVI(KR!TR}MWfoZor({aOXf$+re z#9EEO?r9~Ce6Ipx>H~utheKdSAP0*Ez6<{32iL(M?Oh;ghZg|r+@+>NS{^>f(R zBoU1u96*39LqM8X2~gRS?}yJg-pTqstyi+VS%KqSe+o9B%NR#-wnoYX~L$j z-d}6sB@4Ot%O(hOanX1ubDbyZs>G|<7W5ZrFol?N9wwvryRWeKny=pL6Y8sOlWb#b zqit6X$bfdxXx-Awpyq}~hc<>rTr%v`k8X}GGL;%@yfl%<-jP|5xy9ne8pHy|Mihz3 zTTUZPrxuwPNlww25SeJ3%$qz+Qx%7e=8rn2jizccylg!N9+Wi%yVTvA{OCO3IEY3| zLTf=oMUzL1XXs%>O|nSpPufn}W$3LkQh}@nQQ216t=6E4O*|QrGa#%CVa+W0ew5TCJ=jucRoo618Tj^l2uibb3j8PODI>s^>u4 z7|w!L2v2f*LFSjtR_!$H>~&rIqNw6=vTT*?PdzNUHP&CwIX6{_%7RmczY2%-i_6YU zt;lILj8=_8neG@7F%&a4_GXnWDJy>yoXKGAWbbp!c22${hvW!R3Q0v;M$)7>rjVsP zq`+1tReq;rUUg7*-?`A0WU8*~-Wy=DsarXcx4ctbQb@V#(0c6tDM`I-8L3gCar7Gc z8t;MVffkG-&?&GP`ex3~fuzyTeH!j?Z@q5hJaiL`*p;|^QaFD#Re6MTB1srpn>{koauau0xl3*YX_4{8QZnIgBVwlu$@- zOn&q(+9;$(P<*LklwxV^*BhNvlhb@oHqKzqFwT!H4lTv*)VJDCKu-?$%a^lfyZ5sX zk{~P~-`?**hbaRFC>cmdIPB?{%r zEx}NgP@FstBy4mg~e8(eII(?aJ0R!TX2L1RMrv)GT%p#;fTNjrpWwT+5LEehJI)><&e5qc3-bOja7 zBBdrm)ARh3%!f8t*hpqlYn8s-C&$p2pCPCeK%63B|PTc+Dq%- zI!6z)4jNhwJvBY~k3XMBjSBe-<@R<&*iV0&nq@9vj$!Hu``S~!Y29o2wDyC~^<(kA z6n%F6EeH!P>-k3SE%s>|6#KmM7x$ul;-~cMnlY6xDw#7&Gr=`EOvbKauB-cAlc|^^ zn3P<}FK$<%*NI7$1BRlbQ6q>c$*k#)9v8el{^udV$boE%cAO1WTNA0@%f7D+ddHV) zoY&hFE;c_r%EuQQerHwxrr;HiOle7N>dSVZ2{`YTmqWRrwURSrXpz&VBb@ z{egPry1{)r{3R6~I0W?mgsR2$MPrF$-+kq29IOyVgKNlz<;mzt_h>VV7($XPt%$4S zY5I27ps@MsC}UP@v@*yrBA||s`X%BkXyGWiV3pv3P>IlJ=w0ZtOZipz*2u9Z?09jyhvP%Dp-z9-nd$gpBA3WYK@02s%(eNh-rm-vqw#58{+E^F7OrdW zr_2Z4tKO*nBgtFI*z_Lrn9TP3xpLq2TAo4FU z?JuDHubB29m=$!t@lOdH+JDH^f8kO8t7JV_5lkt17LD`ebBD;Btl(T9UB(e=BA^}& zkDLztXB1peAFn!+ZipF5XbeQkFEUjsa3oYy8yOZ-hjmh-?{blf>&je4-)D?n*WYlC z4!>YL-?$mN9dfLC0&uJM#eS}^2H*~7(L{qElt@cV>Bw0IhTujn020a=*xnYN8y|$6QK;4!21QR_8{8xI!D2-`bVIIf6zV1S(u03{K`Q9HmHMu6Kp zkQapDfxO>h5wXz$tjPc%$g)i{Q4;*XyMPLVdZD6hLK1M7QZT3{=f@LKDTl?8^AUU z0ea4^tN?_r;~I20ncMyz_JP+;l>}122@SwcqMU~Fy^d~BXV)cOHqN!5Qr{rtXYV=C z4YW)z-wP03K{bSJ+YQ`+`=I=ZB_)PcB!G!zYH%pDsOWv=`t?3gdXg8aQXJ_1Z6;($ z;K)=dkY&@0H78LjQ&wY3q}<@g)l%I!f?x* zf@IXI?q-waAREyr3?zKZ$Bu;_{X2Rz9U%61Y~{e~KK~Ct##-Dj+?})UF)~{KHcP#s z!XeuMFpzl}fb9ke{l{7`=3u;JP%#F*oSKjf`|u56DQoS!KpDcTt|CnO{mE}_)bS4^ zGm)l9gJ5jgSk{|~9TJa5Sw3M`j|A3) z-*~t+_2{^v^^jwqqm}Blub*Pn*J8Z4(l8IwZ5N z26sAe(EbuxEjf=ic|wD0DZS~8YY6dT+2qwgGE1sR3PZvS__4(^(@y3dr$MwHEd3Mq zaWGad7=mjT2HYdL4`(>7mY*_vJ;*j5IwuLWXYHlzh~V|zAT$c@YzWI>+^G*r95DL8 zH}14q*n)J(%P6pHN?&$?B`dE`)bvI;%1sGwSK(qTEr$|zdqA4Q>7>!Y>b~q{VW!*_ zDPwA3=-ag3?$ZgZP?)J~FN|xHABzFvV#=B)P&Uh(LX@;!kY?mRT8lj^u6NtVn$&02#k@k29Tjnxoq{&{WQ{ej z$%sVB;7K8ym`!ZYek0}9OAo4loHhE5`l&9v3F(BB>km$4x0G z9kEj|S(4FXVaMK?Ubqoj;d@=S-VHLtKELQ#0LI`pAfrHp9>i1!+HZtI?`@?B1?9o% z;FAeQ*SS(aCKBxMSj*@H0EzmE)IYyShZe;$yGfOx6|O+%U}O9s1QvFb>+Nv`aKsKq zE;4#Cd%BIr&2W(^Dddqey<4$4E%2U_GNI9uNsUZl^G5?M2TO{jCh>EG0RXZg6p)b) zph@o!sKo$`#@}IGpifnnI6DkD5i^1Y7}ec!#1+f;C5}c4?fZO{1wiPOJ^^%pR%`;@ zIs-jM&b;=nHIe5G8ur}=4_yNA6Ksc=h_;?+8=Vw1Svy)8oY}ii?O0M^Xl>e7P*pyY zYhYII)!wD9Q9Y(z`4DTtHi2}a1dP+LB$$Ih{tk=H;LceZpVl~2ySJ3?~+J8Zu%=PIjZ@h)Cdse`ldmuz3QX2J^Z-K;!^ za^utpjbAT58+Q7j5y8BXe=h1oyb{LM9th4&@{!Gtbe+5IBOpIQ6mQN)868?_9yvHh ze&BC_$6X(?l2LG0BIRVF^}a&WgktSZ`C6Db0-fkxU&0bJp;G%R@xnH=enB1@)~`g&AH zSyob3ZdSfd44!8BXY1+>tZt-k@-NL_IzR#5_DQeY?#Wy* zpP-%qpBVX~*ZbCJZbJz}O$6~b*)|J{vWjxaRPDn}%1vSq;HJrofK9%bD3}16s8x5H zOq&dw)J_FVF;1sWWlz~oDHfe7wq~s4^GudafKRNM#uy*Xuw@#IOSSAIt4Q^I-yzYDfZF=Xsl%lt6SEl71++| z>n*Gj-9&UwBrnFszE8}zG&VysW0kpX(Fxs&i?5pviyu6Wlua)P+{4!M+>_XY9x91) zlWdf9n-nC*l#s&UJTzrckvKmzJXATvBg;1_C7ZZUH945qX)t5(-XPZiZ1^OZJh3r3 zKiQJTk{-K?raVDgTF1I=gIH8R)KN5Zn`qEsP*Gtcbl25SHB<+=~J#zB&!dn})@8MFAa#5~%#x%=POLLRdB_Tt#pLWXXx%tRrTvx>eGnkw@8&mr3rTr*! zzK=8h2f{6q9CDLJWZl~5Oqa~Mvh2PZBZ2YkjkS$ZqH(cT6gt!k)hMd$ zmez~#mxTJFF7W{r%e7+0$}<(%qRP34BARY-SIVM^((@A)f$4#69vLapRFtjNOQv@t z)P2U4&L*)nSsBq>zeMo$pU=ba40B`4P?nJHIpFDtCij2!Gw zgVmy1sFoj3J3L<>etL9dIAT~(uD?81%qq1wg_xgK(v_F3PHt$_x+!&qzp3&(ezsSC z^%nZa>8{G4l_pD2l&<^kH$7F zCtHr$Fg)sxgC3#+PAOU!9po;J1n_5+rdXWBoW3=Z*6*v>D%q-rC=QOFVz#a>nk=Ze zt3BKvd=w!bkZ@yBcC*=w*_vwG51oWr+^JdSpuZd%uB0`jPKV@jd=6a09;vEaluWx} zU3F={NQ3F)P(*DyJ<+Gn}X9*hv8Zq%@7+HlC-FY29+GhLaLP`hdLxEEXt!?v)o z&^QP^YMO~1vwu)HC^=btTy%G=IAwn*T+3f?6kR85*=SjKDgq0DF?nXZ(*$c&Z;ZGB zxwd=6xVc;oYzmb0=zrK&x12A%(k#YGWG_0jJuy9oIcdFjn%P_-{z}{lyxm&(Qgd85 zJbCJI^U|zqwWD=Pzh4RC`OWS7i`!|4G4(<~Rv=c>kTdIJ(MI+2p}XbMYE`Sa%Y%_q z`=^D*VNZ$Y%5C@C2UlzxPPbcTO7%00f5_whi(){}#QZ0Z`}4Br4Fuh9f`x#^E8XAN;`RTCYwP}O z`d5vhv5l=ApOLl=4n5uLHv`(g3$(P%znNb@2hGd^@%FO%|8!%fd7X}b?1_c`ZKB>b zM#eXN{?8lJD|?QCg%0QS2=Vu}bPRu8!^rxpH+sgm>3ZA0wN(F`(toPv- zmGx~7oqkdBXz5vB?egvJuPB2)9S+?urqo}Yzn>L<2Kk$GL-(8N@vHbsI%ImClm8{B zpgU333}e>0cXWuVUX;pm5cA~3D!v$X*v7#bE`IB)nn;!ty=4|qHRxNUFyUTI?sTCz;0tXu6G&3n5K20p zh7JbKrof$WQX-ydwk@o-J1H+OZmW(4w-X`Mnh5qAjO!maMHNRikw+xYAitzjFFW;< z)VjlvSgJL6+?muLduo8cEN$;<*2`JUE+OMx99(o?A`h6K6K;>u1=y&fW{6R1y6+p* zV?L5@pIy$zEgdozSIH`luG*zjbLN^iSv?sOf%K z%8WJ4C9AbwV6Ng&gQK(ieOH0*IQixk{Z~qvj>@12euG(V z<@5LrXDk-HiIYyYwJpB{EuEFI)D7j`^W?bi>as^Gw7BI|7gC9PDj#cTpLP{DWKFYb zn$8jmq9G#`kyiSmla=dQ%;k)Ymzgw;h0R>Us|c3;d;OUuk{hi?J35jbKOoH4h_Oc2 zm?ut5RG9LPt4Bl}yUnr1JP0KC2R8fTpR#>wrg@JHzCn<7XszTw- zwfVHhIn;<{r>J5P0)u)HWa~T2qyJ77?Ccn2tks-*N3K&2Xh<%`5aONfk)LpRTiC^o zap91l%oOPh#lciMU-l90)^+{Jce1hI^Ven#m^B{xaw=c1}S zv!)iJyoD1wuGM+V6V;C*wc28ui7N6V<5G>Zc1cri%RNIyrS3aQ<7BAhJp=2It;?kKR@S*O^a|bQ8;Bn1BuT}ax%{~<<#KFoEFP@TwPWtNUErPv;oSQPHZc2g z(@#0&2bIVnLLtSa;)Dvl`6BNp8S)glG$_7%u*cGf61vDM8VrPP*HDkLwxtw*s>h;; zut}js$*QWr>t)xd8k&w!RDdV{)@fc!s*|t1#8_r!p}jt7I$#>IB&wbG-ndL`P){Y7 z6ia^cY3qE0;UoQam&prFXXZfDzG|--A9UxBh~V{r(hjRlMV-1rx=C}Wz(m_6ZnaeOPNn z2BKdgVrtDZ)$+6nMX+9!w%nre@*N;m)#2#}EDNYvk5g_V!bYcb@$yqTJ;DoSD0jBa zAEUYK`PX4cK3ES_v+Qtf#5*$0vHFcN-a2Z`&3xD41cduGXF^u3l8?0Em|Ea?&F9zzVq&w@@XTQr@B*nGPZ}`PwJacL}y8uaf{j`A?Z;By* zCtJ|btYqpSRV83S!-W5Uhr7zrMAlP~ z4Ff`l@oAxsp@Enb$Ss$TC6V$Ez_x? z(jKlSZA(vO9~v86A~+qjuIlq$FPeQf@jFFp!>N`UthClL*!wz*sewx2qNJfqgDD=q z0qf11ZZC@_yKLq=YO|9RI>isLS>04f$Qx209_gnxf2)kQzpfb3n3*4Bb5(XMD6qMP z)%`q8Ay+9i%*zP*F9Q2(N%uxxt~j=6+Cp0VGcYwuHsL-H)gqdiX<12o4d}lJSZ^hE zA7FsVEj<+l4*!F~3mIRz4IIdTb_^09eXEa4K#ts$U*zSlgmG1UllHL%O0lM+rSICu znd2b*bD6_kw)eL0!o%+dvn}S?o9tYz&#x!S6sfK#I34%KY(qFSf+go(XYd*Q7(%9A zTW%31K$_eUd+VfPQoW`%E`kP2moeL|G2iXeK&|UQZ8rHj+!0tH&wDk%Qm@4|N-0%o zbM7w;WdhX+3|%=UraEi1w<@8uP?GMxQ6Hw5rB=D!fq(oZNWPV3s)uKFNYkez?p5+4 z@j7A|hpukfXJwyT^m`tiIL79!w=$+#-5VT7_nx13>gUSS_%lDD9w+wCZ`SiW z9LQPdk!FvaEKf!r&409%te%<8cgX_-MZRz$nMq?w=w~|K7f!@1bdp_8bJtzI%fBc& z<}fpnA2MT?0-FMJ63f3J-U5(20aY)+mr}{7!UN(r#->bf8i*asPkAQApTn!SXR3wG zw7Pt*sD4-6gq97(lT2DP&|;odwohu7RTkVq1d&YgccETj-Gr2+uBHZB?ThDcA-Eunq7HTw-V(*re631*ljw|BFqJ|m zdn0iddz_CiRP=m;{&h7>IOE@0X%JOa9ICh;hfeDtrmQvYchf@_S<`7c8L+2feVS%= zU@D@b=xTtOzs@{KP%MJMYBqPQkxawFVCR_E=)-zxa;J#@yw$U?Jkf6o6QfDmYH-8q zT=GSkGrVbr$k}2si=Q72PoHoBr++uxk_`3JCq0YP>*8+1;D z9oF1~naAE$f__+h0O*L)z`PvZ_$Sc2=3rodF*Xiom(O2Q1TAeAfUC`GTdQFEv%=F! zY;GE{|>erI2JU)Fxe{kBIIa?@HV=2Q@h>{w%~DnVPI*QIGUN^2e!3-6gc@o z;HusL(9igp5V}GOWyl*(36!~=(h96^GdP_V!!xS)BYJw}IqSdeqNzGuJovYParg`x ztDm@i9{fs5<|PCrw&P8%j+9nO3D7u?Ci^K zideL_EIo|O;rj|L%to;Pmq0N3>8++e8ot-QhlV|!9#%9DU5Em>9IA^Bc98q;f?k%- zUI}~t6jQg@-Ig~E{%GJd;C9FeWVHVVEcpYScFWGi-NBK zWX5&mylGgtSKygK;2gYraJ&()E`DS9es5LIZ_?HtoIpg530{|HSR0RMFUUWI<^#e^zink-x10y9HWKvH0{0ZjGa* z81o#o#8SoF;su3=-h*;e%I=`yxyp5o*1e78Cqv^83k)gJ_|V2(xM3_gaDfaPk%AZ# zL3}4XH<)CnzQexXlW%1A4zcV^3-&UA|L*O|oGWbo=Z7A`WC{iMg*=;fV>Hp1Vl38K zFT~r5#da#9!Fww0XmFXrad$K}RvBHRn097Ur|6-RS2Lg=3ZzG^H}(VrOqm91hZ~NEItF5n?n%1$~B2n)4-Bpz0j^b2+ zo+-=n*5rLw>QjG`Xgrca%&8~VV3ogb`+SlXgDXu5Npxu|RjcYyXJ_k$qBqAz`ivis z!&glk5UitP@cn-CkwU%079(3fh6HJPdJ`gtuNma!lN>|l7uy~^a|~ugbZIr)wo$fc z&^9(9XI_m*pz%#CTiv+S(9YIzve;E1n%zxvz{yRSO3vT(ZkK+CbixC&%Qx=l^gT?S#TAKb!%l|?XAn4z~ z2^k#fzkrwj7>c2zdCl^FX8ivQ#n3U);Jp3*Y;??TIKY3jLHq<{a2Q$NhW$TpjLd() znYZsG|B`=Q!AQ&c6O8!{%KQd!-e8(H(B%!5`323q?OA?9F>iN#Yw-%sydo$JuMpbX z@fV!)3VlGl_4W4qpa0W;c;+9$rvLETf4%!Z^z;+L`8%rgbC&-AE`LFJf7!t=yZD7F z{iD_V6R1SX#Ee5p$MOm)y+KB-4FB7h67B0Jm;Z(-F}zOb-!P@0sMKGW68*35QU1b| zepdV$;%`jpb?SZ^_a97&j)v*g9{-o1(y-fmyV%}XgQu6${F}7v{2%X2Bw>Vu1Ri|M zkc7=TBtp%Yf>C^ZgT;Hoam;%qB?AlT6cKzaOApx%iij+dj=Yx)&h3Q;kfLQZn~P%<@zJuqS+Kb z?H1Ju)-%rn>p8n|dm4&iv);+_-d1IadKQ3-dMRGbT0~ zHZQ69xIT?Me$Nn1cF;{2S10;AXJDV*GbJ4t@xVex>yL@&823Ns2UqwEx^o;aF^Uo} z&N0ZE<|&v`zXMf8S@06E1AkDUzQ51A?U1fq;SaqL%HHva#vSclx^%u_-%i^+QSRPd z&NgUq{cby&dQv~iq3Jjpa*{Z>%aNVe&k(<^_q3Hnc8+#`=+Uncp=KhNONG_d7yhY5o2F5!WFu1m-D7+FHPJH zLj8=tag)kJX@hoJAa8VtmN~(LJ**#_npt@TooLk)aNRxHpES|=DJU2k>e+Dg;W87> z@(~^1K)ajAN~Y{2P8q)^Sy{c=XtLvJ#ii+%9*&j+5Mk(>MiWqdl~#=pGj-ka=Zil_pOs+Y00wP!xaL3lpCzSy(_QWr6* zN_Xh&(f!FNtnz9KAEc{z(*ngRJ+qZhN9kFgo6c_@X;xm9 z^!XiU{vEwI{meenn!%dKB~|Aw^_d#xHyTLTT7YfyM25-z+(hsL^?mmqwNnmbc&DAR zl$TX;Xu=P?Sjj!qo)uyZj*w~7JHp8L;}`jT8J;Kk{OzsxTWvn8$>fx=Xd<|f6S(Ji zYjk~VR}|<+NsuvyIz+1o3A}4{q>Qp+s8aQXG_g+4FOSirsSjCqS)LRLnCuBP_)ig? zu35x%h6d_=E77iOrw`@VbFO!({&{E38(<>OoE{l=Li?_=&smRp-4SH9itaL(yRx3( ztRdLoo9RA9!m=>?O?F*FW@xmPum(F}2@Rd#;$XDO#__Nr2@BC+JZV*;JIXQVLvqnf zo614zFje?jg6CdIsts%lUy_=xzdLKpHf3ZtQz=JdeNW%5u0}#e%nLkMm4g@UV)ye* zSzb2`4AFJ=M>Vc2Dl*8e4JbW4Qd3h=Oip`#oHJjM>>c8OL|Xcote&I}H%LhuB#>V- zWEOIDLzO7I93_T;P!n;R%<10s5+bQe3qQ&b@lyHX=Q%Z%Z;sZzWsm^y1qa)m870j4 zz+a)ateFxZ@cm49LTHn3!o?bV7U&QIKj0Dl2c&QKa}(%3R7Ny|ux>=F)cv50RA?Bq z_2T+qq_Vpo>VshMd5PRt#z^MKXZ>{Umhtld?1lwYtv9{Xa5K;{q$4?BzjhGfcyL64 zn+W^?l%&eepN4BZe^J}k4-`-^X%-4>NHUB{pR=Y45$-ihxc{N7$;%a?sX!~)#}NSo z6j0p&5VuN0%K;Z04jSn5g((CTiPL~jBx_Lj4>BJFCkSqcN11laF%)?E9IbdCMZ{3D zx{Ni_ca3eyGAUwYYr^kZWu%~XV)i}I4^=Ph$efhgrQcyIc@+Ya2%hzmh%(fF1Ok%x z8?x{M2B-U0$;8ABNU#X>HG)um2sJ@nrsAU(txt>_%7%173@gk!vl4HAayA_EB>)t!uK`ClN0m%-z`C5mIzY|Gk*F z2r@3r@+NpXO~6|spX{K`ipE&q6$LB)_Q3)2-5At9VwuKG2pdVby8J$c1|h?%17)sK z;hTN2R9UN3pDBveO4;^)YXT3UcIDh3f})HPc9cX7GuLZg@P`FHw!GgKQgDMZW&qE-{&)G&#FVg!?mFmoPD$LOhMpw$rl~;kqFX<0e4C1MqF7J&ezqi_I zJ1YvwuJ2Ur=&c`pShQ@ieh8R9woTGul)X?uM_rUqd6SuF_tny>KW-;AR@VED< zJF)?HG1_4LU=ljHAzfd1b?)%Wv&LY`oT+)Xh`+$of;^v`KOfJjohFvQtd(FbF3#?@ zj@@uQNC`vVuZBJc4ySX5a2XeHewdgSx&gBL6l%!Uc*n+2P1C{l?(%)#Y=m(r0j)uC z&z3M2rX*TpI+HLFx*$q8m;;U;HFzMcKMZp%!Pjyogt4el#YREnjyG&%42*1=Tn_vT3Rw>dPy^{i~ap>esm_(eXrVS74rf8G@!hZ`)ud@rg^t% zQc3x^y^RE_ov0k=|0(RNquTnmZiA#~DK5p`Aqf_wxVsg1mqPKP1p*Xz*HVfVcc%o0 zLV;4;p}4mchw`Pr``ve6Z{Ha2jFV*SdFI+XXJ_yHk<7VP7Koj6h;a%UCvV>w1u!m` zHu#7Uoc#kQK7+}l0d*Yz$B2v;tYZeCKqV{9!{4TPMaW-)JOE^2R2nWSVxqTJRJQH& z7-_P2!9bSS&?F;Vr%Hlj|8oCvaO^_2?2+E|rUx};R$P@eIvWu7^pT+k?Sf=~Q*?ol z)UE+|yP34;18s4(*O>m0y3`$hx2a=fV7$vS{1sGhG$j1D?j!?CVb}N>PeQej?7Tv* zMzdo(QUoHFtCAkbb>izi@D!tSo@9n2c`c>`&UUdw1&Hnptnb~BAzRV>Oaz~aMqX0> z@}lFAMW5e}{vs0o=5WwTb>c(#yPOY0j9voRhMDnlgdHE6)?9f;n2gmykNYIQn$Jmn zt_jb2_bgil{z=J65kOxpQ{OYA?=*xx!+qx z53?~=Xcdjj8bSVtpEv24ntk`N_=g%;lBC{v`)&&9vNH3#i6JtVhY9?&;glb z;w%;8&WJ;?_uQx?F#VI?(*YGdywN~O>9`E7r0_*eVFk{y#|z1P>o;RfGm2e3>>OMQ z{JxaK6x>A$o!N@jrc;{g#-`9lONYac+1siIe)%@9Eqz#aF_60~^j}T$)qkp@T!7yD zmzo*WF=!CR3V1x9_OJDm}cPZdA>DNHq###p|v3Y|V(=XSMpm+NojU1FxcZMuW$6YgD(5bY1XfZ4-wT zD%ad(Q`8J5>q)_mlSx&U(z&rLa%Z@AdhMR#tv*+T3R@or6rFm~brlKs5IIgJm5Lb$nKBfHWHT zuVS-mWah}vqv;GLNlnvSq%V|k{q@21Uu<7GIr+U8oB#D=!NTbbxlUih97pr%{S8CP zeYFy~ANf<_rnK~Ct`~N@P8^hm^E*4AUpTYx-58lVIj!!rDK2E$ZeItG?2|O$?($-hM=kwVw@Ttf;PKBZ@k5NR8bQ-NRX^>X7SXIkG^JDW9q>d3v%=nn#ywe zyu)Hx8p?WUiqy5y`1{RC;g5`7vPs{|1xm31-|kapT??Yqda0S?eDfLG@_?QfrMF z`kzU%`<>!-6Vl1tXCQnsO&nTrUxU>Mt#CnSp2VRw%1WacsC#hDW8I89aC6)toCWS! zRtzB>v5F!jn{WkEvk%eKa6)SoU!`&%sO~WLyezeCbX&uS9p;PcdIMA^(%@IL9P~)i z^y_8jv#C~{pvui>6vApx-L@s_u#BXJZ|&}?xCX0+i$`X(isQQr)xF?|)nXQSlsZGg zQ7KhWFZzhHNIYs~T<-^PTM8JR$}!IJZbkd_9gtV7-2Ao9VwZUD)!x~j4oC&oH968$(@`~Kk>nprliD`&(mEMzvp{=Q$D)S-Q`Qj4si|pwc*RD zxK~X#l&n8<+MyY!-w31=W9{ z7|KhU&00wmMhiu82mL+`gUIBY+V*K$D;6Gyyrs+(LxjhAks)n*^PQ1}7Vj2dJT)4qc^r z@cP96R)iq}vNAW>nn}XFnUXPJv4roG;DADVpnovX>Opz55 zB~4{wre^ye1F+1Qqm85Nn6s>1ci}BuL2fSIt(DHGIhUBQ8o%bcb^X+29TCh*5HrOI zL>NWfFNK)(ez^!mH8#hK>85`xD{Kq%eR2Rh(i&Wbl6xk&>phC86B-r#h39+4YffFT zjnYfP8}9L?I2Z07{!m_g9=@v(yN&0<-ce-U$MfeY$Uc$Ztb%O`Lp?W*i6>sm!@1;x zKvd%r`4l~=HL@~-g%?6~Xg^-_PMAKk)ybqz5g1eO@^7kfx*2d>2={d;xu|eB()(h( zx5c4nBGg%5z$5r_CM9iuk22OFWahK!{3uU3`~}$qL(8l`5-JB+ftw_af+F~ud5<3^ zb!znzgE-?IGaeNi%G)F)!>8V**j~^93Q1^;%hPq^Q01f?F&}hMVm39+x)+@KrHojO zr&ZF#4#SfFYFNEXhuw|L!?bmi2XoT*cYR)QIU#QnM{WtBd@#w^WrI3lx9I{C22C8AQSh( zGKlCS!?iXGCo%V+kVr^<4G_Qi*#x9jHm5C47^W{K-=Ykyd8YZ%XXGrbb-P=DT0wnlW`5;J5^uXs*Sv+WE-qrtV7E=O{f!?pNW zQ7cFDX^e)3AC-36+N6owT)t7zWoBOZ|OMst~9N}htQ`2pEZ z6=PR-!zG*>ysGQc9QW%nkenz-V?qLsB)H+~XNqu7x@&r}q!P1x%S1}mOD+iK_xb1} zDbOkmf|!u1*+`$eOc<5>Y}-+x$>Xu|v57mC`r1kXQ=tQSJLBg}w`DY4N(({@78_=z zxu=(33r@L?u^jZiatOmz-5OZ5cFU)LhopT1$3Y z_4@EroFzBz<-RPK)|K7qB5}UvYNPIIH|@e+e3@J8(O&HC3wa7@N+tm}lS_6|5}|VG za~49E7s-%lx|j&%BzndemRc$xg-!;3mCHGDaZ*RSLbr>F{gQ&} zdxT%Ao(6!s+_+Iujl9V)mWq#8?PFLCmN~a%mdh~@3tY0Ng6m~aN8MJ*hn(oq1WQM( z9QM){mb4gsC!=-7+uOU*tUVP*N1by|uE%^$DhFq))PAM;Z47?PYjfEqF1=w4P&Xli!P10a9bKrJz}iK+ z*stjCB69U?)gFCobHTjq1M;^i!zH2LV`9MH>~I+i2Ib-$NCi;VDl8s5$Kj?Bm?yHa)8A_=O~Ne!4` ztEZ5XFi}T&eineTDos<6MJC<8mUGMBNw`}VGJL{T$|TMzB&+`LWbJi2cJ}%&642YA z!_&5b3auI~iK^|y(amCqSV2x7ZD&~pLL+{q;m@S>7Rhu=dq1UdZ0pQff53T#%pK>y zsjnO7*e!_uk}NhO#Ahx>7`M201JMUG<9xE~&>{Rt`-Jp;@Q{{I$ZT@K4qEt^MAHXo z+PT!0d=&a(eX&9Am~re8_zBt@?Uvgp4#-X<(;*q1#OfDm8%0xGqCeWTeU&AeVXr;= zWzeCxH+_;?sb;0xR=zX=HTZMaNI_k^1Yj=}T_Gti>2tzUC8|sCUUXqh3 z01Q*olqLL(0}M6DPlmeFYIL`l*gq)jvz?}2eNX+0WuvTQLsaDqTW~PeTQo=wk-Ncu zfzc^k(x9e433{fftt(h=?4kE!*p@A8he`ATpq)9K^)t>=MaO%UDokZVqh zNGG%Q0wwn!-dzkIP>H_6B-e}oiocJ&4l?nJj*k*&msR3ZhPS>Y@s|;}png%l2@)m! zq_zOknMj%Mc{!#Ri??PsdxH(_ynTO&A&d;-a8dSwj0>QXJ|*sdjbeG+CxoCaTZ7B!8mrY4&YgEaW*G0(md5 zFN0;K?+Z+ezBcairT`6Z0dUW!@VE~+!yUwQ!(-=JTzNPt$DyXqVB{w@3bMkHL!%@H zqRwyHKxjYp6!~&#Y8osqr*x?{y;{E+`i)mjUdD~!IiFNaPU=HHg?(##JJ^(aan+PO z*rJ=aJaY!u$+hu@o!ftn&%LNl<(u4#6T(>V$C>%q&OwWDQUI3c#vyG z*}ZkCLKZx$|0L45opIP=_5qmA*`c6|%CwA`|59hnl&hTzu2-sqPc887&?9DOh_zri z86su8utJnsWhEBBe;wtATKf>~hiYF@-{I*<2w<~2y1)-#%1SC7Gu zk?+TlUk!bSzTjou^H<90MmKPMrA&-cv4Ms43}-#8!`y=-Do*AL*dN-^BoGDBNQo@4 z)tJN5@clmTMrgfGY&Ku7gQt~aBXRiUT#ly3IajgMwCYa#; zhta*_k)0IDUj331q8CIozkE$b)<@q_d*DtWXJ<&7oPJ(AS`^+)%<<9ziquOH36yWW|1e_=9|G*ug z=N#J>J`^2vRgFqNT_iBN+=I!4jjPh7f1c{Pbt2fxO#SvYgL>q8*z~)kQd?u%ZgOJO zY9mc(I91e7o1O)}IW3ddp|Hi0j(#3jzS-psg=Qk-&`GISTC3r-gSi6o%Wqo=&%-?u zttrTW7oYFEd*uOL-(>aL$7P|p6_A+Z&2Kf;>FnCEh=`PpA`O(!dP}r57Mt| zb+w6xv}v^s4>PXa&3^{KbrdG!tR{`d?*hmdEVfyi9t8;15trLe#6H-%En%#Liohfe z4=-OMiWmqzP?vhBGMlB_#VfpACW4so^oO&!p~P%RP6{>L;bTccIfe$Sf{JsT8)-(A zdM@O-(u|0`J70S%Iw?K((eU!JH{O}jdpoN;{k5r$MxRRQ6brOozj$z4wyD^f4uN9}QiIwuz6o<${yntRAg;qbamkG| zI4+55C6_^WT)>Gqr;Y}bzT+|W)T2iZAtS}HztjiWVhaPm6_T~x{m}i^x5a%==g@b$ z|NhzDn6!qUFh{*T;ccDd*NE#7wahBvXF2b2HZG9T*rybj+C);9ettZ(tz`Q^-wCxJ z$4^+krsO#Zi)~2?vQ1-POt$u`4a9q9uh{+{byK$3xWmjMqE}@uTKSos$ z1e_)XV636JzLDK$PqoE8gTNYo)mbx`#BipO8{+$oE$q;q@xwUN8P?iMLuX`WZo*8G@Z zGx*7mx|Nyr$U*aqg^0~3q*!ZFWO;86=Q!-A^1+55tM`Sr`z?oiu_SPYs3JEy3BT$) zM7rx>+!w>#6{V9rxna1jtd>Y$FirI`=lp}2toAZO=urvScOM}p-r_YxA- zayGl_qhW_q?rOWtbUS^G4X29I$i8Ai1~#5E2uZ_?C*#>ugM;#e0$^&`aG9NRf|e*d zxUrr|XLcx)S1>{B>`sEGzkN%;;|w4F1p7BsVCSYe_ePNQuf6U*&IvhBnu_Wt<&qVp-F zO{;WniPy-9V-G8E9+HD%ie9IpcC3VTnX&`W(FYg<77e#CM2!r z_qg1U0zVG3T-tgJiT%4`rmlBu!k8=g@M@G+oYujO>o)Mbm(54`GTP1>1H2ly@MG%J zMVuOSi%Pscdg!|$hl^AK9{F#x$j$Cq#qRvE7i`IK=5>XacV3F(&-9d%_QTFki4249 z9w}URUaLMFV09g@`t)8_-DW*B9(>&C1YZPQ@?r3FR$3Z%&)K~V@WBG{91;9_PYB{f zO9{5j;PhBb}!hUl&nmWoONn8N@xKT*A~kt(^Vu?(2n zl=8dMlND_uyy}>GjlXA!wG|TXPns@zK`$zu8=tymDAsE~&ylbCx|1dKi5{+Orbmi` z9NCNMwaJ2FMUoZO!M-q6i?lLOwhFohW##&mCPU(L6H5+hmj#90U~`V^TRbm1aj=!e zN%A9EHL3UZr#nUFf)Y$L0_+1MnY2H-v4O04%KQh#Zmlo^R0h-d*hq_nLl;s?ocFy~ z$Z3Ak#W*w-a%&|ddZVqo(x_*+64Z3NQm6qD`A_ilC$G354Fk z-<4N;D(j1ovW|7U>in%|6_`p~$exSr*yjW-k2ZqMd9xyAdA_hP0NaN;5Pvf|Ne2bC z(1-azGclUcH${bT0=4B-jgoX@{;ivjlk9G;cPG?K0^?n-vp?uZO+Ax`8^j@1I z0H@`PreJ?Fnp*i`5X;<>!;Gn_$Um2gw`Qrr0g0=M4)SpU*>=mVX(%|*m`!Q|sbSX) z_6b1>)cR~+Ug8+0bhd zGXV`kQx{Uprln;3%4xmS_ozk#YHoaf^{JfGD5>HJbKu=(me}=zO5lA@R+qn3KQr^i zk?{9nu{)H~G=aPw%HW*QCu677{_vXyAsuaBQpc~oknc6hIaCH{G$AcY!OLxKZssg{ zD|40iucd=y`cy;6Cwa1dCc)@2SBPD3J7fdK0vYk)&Zz5Dsb6?79rBXwncrNKvZ~g_ zxsT$;`Vdf(6?)jz`(b3*ha+Da6P~EG7S3nQ=S3Mv8Fj>b5Kg)?lPha2q&eRjV4@*(QxlqD+h!tvjsQZIX`lr^bOk3}Z2BIDH z6{YB43z*hWK-}gc*L(4YF;@Ab^gfcoD(cz7cp_;GsEQ-6?D1;|6JLl%*7in(pHett z|HNI%06Qd@2?xa<*YQzl;dz)yWa4b02qQPGwrUEqbf7j)i;MQ#z;EYYJY@Qkgo%X%AS|IF~-C!D>EcrTWF)WHI;nJ~`Dd zfd{Ok_Oyt*H!Jz*uUp>#ig}^Kboi2@<7L6W4eaQvp;o_&!@HBVx@TEZ% z|M;h(h_?spzYXaBc$j~8#iDJ8Fl4*`=fc13>MUwb&i07RU^X@gFR%a?qD#nsNdNYc zvq%deG{1r%euw}B#0%x)HvoZ{5$FG5{yPcpZxg$Or-$83gn9e7Di@(IMpP%U^0Y)0 zdi&=F5P%e-z8k^|jxa(0i||hy;X;@GomQOZ_mBvZ%1f)?ZOs2||3~fV?PhI*5WeyV zU?Oy(|9jBz^YI~iv!VGH27!VRGT(o$(K!Dv27*8kPUSx_Fa!ie_|bnK|KWiU%>Tw9 z5P|=W1wnX!S3&tB7SSIcVj}*)KnQ*DfAc^HZ8Sm<{U?tH%>NgUPk;|04E}=$hCqH# z?4KCFz;DO@9~g)SQJ&^6On~RF``{7a`wK(d+F!A}V7|XGzTc+xKgZ?e_2IT|&HTO`yzuq5Wo`1`l|L6}40So+%@q_+*3@`-xdrAEn%P#;zti?Yu z0Um_N{l783-~RPKc!-sODAV&7_Sag2KtaEq|9{3pL4U_W!M_We{F~?DW{xn@yZuu= zQOn*Ju|E(=5Hw%D^g!tA|FuyRoNZnrl0p2lX%wUp=^#X`p#lPYHjv*BbAB-5^8g8e sA^a8~C=ZW~6-dxR6!ZU2`B!EFcMrt(%0C+p0)_BHFc}$T)MPRL2V(I*NB{r; literal 0 HcmV?d00001 diff --git a/figs/Hint.pdf b/figs/Hint.pdf new file mode 100644 index 0000000000000000000000000000000000000000..e81f67376cbc8a754cc345d4ba293d71f11ac99b GIT binary patch literal 3745 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 I4r++#UnH;`&j0`b literal 0 HcmV?d00001 diff --git a/figs/Interpreter.pdf b/figs/Interpreter.pdf new file mode 100644 index 0000000000000000000000000000000000000000..8dbed557c95686777d8cc063f069a83acf33faab GIT binary patch literal 22403 zcmce;1ymf}(l$D{yZaD4xHAL@?(Xgcm*DR11PJaBBxrDl;O_1koFKvFlH|>i@4V~& z=idLncg zGD@4+m^zvP*D@POim$Q|DqlvJIk*%=_kdF`E!O`Btz#85aEJ|&_hL97r z^;&Iuf;*W~L%Tx3zEbWz8$YrDvS2gRKyutR9_Y6BK}8p9AtL__Tp+ppKvR$2*e56E zGKlU;PkUfIDUMMsB(E1x&8EZ>WTs!Y#Zj2M$WD9}*bkcmUd#o;6qt1X-TZ zcWJ0^fp1B`AHR_G@p1%T8(Q?(B6T4rA3G~XuOK~&*p?Hw5i|B z*=I?e6zpuvjKIR}^Kd@yo^MP!3N(+c)m|ZHV^tVLOg4Ut9=+H-Ka!z??QJwJDZ|40 zK7rQN!V2my_GdjzG_$Iu9u{APG6GQz4pf@x0npM?J#kfK!=c^87WW!s zr6tzsXK_Z+{SMu`(7!dPi^++`zYcE}uC(9f;&kWy#?22+w!7S+-%YQv4@nLM5w*_d za_R96G6KfWbOM2&pPx`P9G3`+%+;n-Bqkahx5hr*T7TFbz#K{dW>m*Vm(K35VH<|= z^zJa7`RzxyDE(bTsdNI~efR~1t3oO=ZVu{F;r>>iDv~?1mUf@i=ol|!jAxiNi zVwh68a%is*=&R1`=LABg?Y7iddX9G(u)}xUsYjg|610Q9Qfu!*%#)yUl)nZKvIiP4 z2Zdn>&nS2hS8>qQnwDaS;@snN2PjM}z^;N6@2N|8-l)#yk_)3)R*mPa8gm(fZ2BQq z5cL27{7+X4=-pqUyCpbq^gEMDPi0SN@=D>QzHMt?I*n_Gq?G3J2x_iEUqZ^Gn^5>g z8#c_tr;B7aT0nkDV7enXx-}$V%ZO)M1Fyzc%mw-3uQK`1O8Vk*)vl`&@LtJef{zCC zj8}Vae~|t%fP(cA60>(P6l&>{yV7g%BODMG|0XZaqd8G2&2w^w19)9UEq#OL}x*?-Eqn&J}gvn^ySaOY` zTm-e;{_=HPSP38B4^C8$5x`l2FL=qG07iPhDvae;+qHDoQqifRW|V`K318$nR#-*k zO946}C%K#F&G7umyip0>VXp*MA#>>hDxCG|KDp~pgVNI@V;s0Rd>sl=n>T08ifLq3 zGF22@T8=XoVIf0_!$HjKqWtQWOKfjQW6ktgS29LZ9mE;^XNB$bH4Z0a9EdZR*`UK= zXlpy(;v+@@i7?1;K>6{P81nX93it~LADJ{RJhpdvjnGq_1@BGv>kakMH|Gl)4sv)S zCXjHXcf+A<3E0#zGI}M7t0zH4)S9BPJw+-o%kN1$ahZ6s!xF6E)yHY1iqlyeVl3kO zgE~OQfQAV(G}!ek->CWCs`o&!=wgk)416U gkEk~6>! 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 Q;RE6UV$jh^C`e-bKX$i->i_@% literal 0 HcmV?d00001 diff --git a/figs/point.pdf b/figs/point.pdf new file mode 100644 index 0000000000000000000000000000000000000000..a04fff468054e16d7c4fa31414902cf640b68b8f GIT binary patch literal 14818 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 N7?CL`MCHYh{}=hlj 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 literal 0 HcmV?d00001 diff --git a/figs/stack_point2.pdf b/figs/stack_point2.pdf new file mode 100644 index 0000000000000000000000000000000000000000..6648ec3c7e38db20329b21e846f80f700768dcaf GIT binary patch literal 20978 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 literal 0 HcmV?d00001 diff --git a/figs/stack_point3.pdf b/figs/stack_point3.pdf new file mode 100644 index 0000000000000000000000000000000000000000..b982cdd370613c33be0ab958e835d6376f97aafb GIT binary patch literal 22385 zcmeIa1yo&2lPHY4I|Mlp+&Oq~cXtSG!QCx*aQ6TKf_n(=4#5HhNC@t30fO@mk$ZD* z?yT>dnK$cy|5`%=XP?^LySl4Oy1Hr?g`%i90}CT70!7dI$@*^Lmsjt5`ViOv%m6zh zO9WnC0F$h#t-13v06Pez3}6zsuy!_e1btc?I-81`8rzwe0{Hn6oSYp^4Q&wI!E4p! zR31s7wH{V(J$~{mHEa9wgoV5qf$DP+Ei4agE(SI_c%5RKug#sb-q@a{hH%$8sba^( z&e)9I!k)ROME2my=SyKi1RIT0R=$b#Db~r8v<6=RCW`~I3_&MXbUz4QmGd1Ri4;4H z&+9vr2Qi=J>UAHJ$dqua#|mFGOnVuZ`g3?oGUYX?WyRErb=8@Jga?^!3Y7@9In4 zHhmjgw_O1Z4TX%t{VT)T&lM?9g3?x!WPyU+=LQ69O$>m3FNP}xzUJsMVLLH+EV$Bw zlK3gn)$iWh1+BnnO z2HS3V$`|8n(l%k`;PXQckk8-G2B1VMio&ASi}aoy9dYq`w_I@XsNhV^h8c}Y@4gdG zfIZ)zG|(Pvf;sjb?c8)< zz&)AdT7Q?QqN|oIby&!a&5(KqEx&wI47c*iVLkErK~f8qx@VTkJ)69Xm%RTI$U?o? zeey!Q>k^5=a0kpqp-bl* z!4i*qD1%=%q2(kku+Vd%h%tdbjnJ|`_RQx!*oloWoFAzgq}}yo++pv^LYByAR*W=$ zM3`=9hm0r^ln~Y%Dw**vJaXt|?kh4}*w1!H*5hnpZM*ckk1uae!=Lc?v{i+TQ$mTa z0tx!}HOj)YaT3z3jbF)avQ}s@JUTLbk!JNtWxPpi*a8^gm>Sg`9H_L#m{e(?)L>09)yA;U z^bCYt7dTZR>N9Sz2s0P`OyTPnNUpgtwtJ5QvKA*`9Z$hUNHWbbPmd1-NDzFx5ln4O zekdQ%)q~D@P*e|}EG(>C4|gA~fxqZ8RS$bp0F$Dj`M1B0rnb%i*6+Ga+0@C-#nIT* z3Bd6kAYy0h47%?Gc+iI+nz}m!n51k#h=qTAiv0ML0_XymMC`2X998TMjZFa$YFEUG1;F`$ z76Eh#1OOi}DuYxlNcDn7^{t6G3nOS0EPve4R4}qMHU552%7zWV@?+RiHb4N&xBdtq z{OkahAJdbvVF7S`>kR^P09gLGW(BZ3Q0yDJKPUI?aX)AG!z!@+Fbm&_`f~tGDlSIO z-^l!Jx&S5(3loqDVPWG0FiDzPm_Ks{aBzd>4x+B3z1@Q)L2!0-0j=Fe|7emPmgEnUwEx~84D{3e>QaSdEm+a8<2g7a z3=$r*!T)C$Zjg|!^I+h=^X@ltK9HD&o&6_IeOtM|ll}XmGyPj+=LG&ibvCyD9MylU z?thKy;K(4VcfIfc`DI{3@uN|4Bjpf#<(Q7#8qvEOVx?Z;bRp z@c#ix{U<%)ZSVs3pE&ek<_|?h{*?!51m8W*GHqL#-A2#lBz z3PL#4_Y%qqt32du@G-FxPr2J0(&wZ{hk6Eh(U|1$v7}NE{VaQKd32;g zskx*kcsSr8{;>sJ&z;pWC|`nMMIP++L9s*!QTMpI<;Ftv6u?o{klso)L3w4?CM9aU6gtVo$_QwYu_6pue>Y~{VFYPyPMIXH>*L~(j>$Y9eVQ~+ zZS;>-hdFimiDrqm`<{894gl|MId;x%2Hz`BaEO&Xk`ry{$EPpHa&DSh5vY|1w~)`tl8+mJtnjbw(neFv~o|}ZA-R*6{-N! z{G-iBjZLa+7PuDASFf^k6G_rr$JcDy1P$&u@Xyjw*CSZf3^;gm)7i@{n-66-4`rYh zHdP82E40njv3*btRtBxxly{N(YI;v#A%=RbdAB~$URnc31J1;5&dYSZ)?SHp861$} ze{6=^$i#Tm$Ra!xHNNQhxQMXZZ+&NE)A4M>xWbd$u8~_`?8T+_)QHFK*h|>c`!S-~ zY#yPJ&i9s#GTGTf6PApXtK3)!mJ0S_{(B6zVt2&7faQIqyJB_y&OH~B*Ng3Xu)Yv; z3kJNu?{K~``-4odbN-<&zHROvV805*kG<=^B^1BftA~x{|FBe~e^$WM!3zD{m}p`C zxzrVB{60x%XEChIuPJTX)2t;x0q-L==nUoVkwIC|3bO07hIC`9n2ba60oTx|= z6kGg7CHGm*uq|+N+vL&6T~^byjNhf}WN2-&bnt~7Qc=zc$;1asq;B|t8+bIRXhTaE zEiM{VA$7$k>1KF*s(2v^2%&Frfb7E#6TQY^D-j~X%VnA=BIg6kLUxY zHtd@KtIi+G0(u8_Udz6z@0Mh+!mvh`8zHVl1?nltBs|09qQUgNakdPY$bc&R{Mlog z1nyjj0`Dk$_oPv`mQZGp&5+!t$brM{syp!UIG#!FW0BjGCheyIanpqDgz7n*pXV|= zb3SSs0okFGKA0HM5sr=~TzbcWiCIq8I$Mp0yfvoYZ}A9-5GK27je zlm?@MUGshmNnd7|-?OQy4Ls>AWen$#QliqiSt0e=8?3PRX*&v;L@n&MTbI-FjHpR- z^5?xqSFUT`rStSLqE6@25#3>pg*uIHUeHB*`x|fQP!s&lJu`V9*NA3h7JB7jB9`8_ zTst4()52ai^H@c=8Tr^Cx9AZMuAD+w&JUJto};u83$5=OlC~ead!9OmYBEHK0$YY= za5J=L2XOgGd;;H%r^MLRCr=*RhiZ0PO8YHRV;mt2V7wB^5lqJF0kbiIf1jfWkU=nd z&hZ9nOOZO30-8nekrsqAHP%3U0N$%8dhjP$2qscONbkjy!H5u`-@FFEJbNtj93>b+ zOBoIFtsjvLlrEu1ud;yM8oLVr39a}Oq8IXvEpwmd1#Tdcx^KT$&fut2D_$DJ)_C1K z4uc(gW4D0IFO+|@JaYcd8%RL?D0_!X=SyQ}weyD9xyv1c>dC!rrI}g(W84l>)(Up* zjHWB&L9eu=+7WtH4t+lTCINJkEr%JWH;tU)YVf&-%4=pPhnK@Am__vF8|GBD$gr~t z5QvCn0kt3JbaMu_+=1)~A@7D&9eMc)4=fyxl1^%)-`-$6EuZ)Impt{nfl*zV$OB8n+Z_(&W#i9n{UxZO1zQQOe_qbi~r znCQa<2|@#p+VL+?c(@)#{DV&VdECj(!SZtp1N^zE{#7UaaFG8ko%FXY%>S@T`d>r+ zzlQq%vZ4Ozy8L3Ozxfn@Gt{g<&T0NFq4=9S^FJ#Tt#KnLfdI51Lw_<1#auQa6ewfi zm1_Zm>e>(4p4OY9C#Ij$w1Vy!TDDrSAkosrz|OHCO{2Q^aX#=Qns%X6Z9yT zv$L5gNmseBhNMia9`!Ph!mt*BOWEKL!s|BB@px#WTD;0{QZsrVGN3*Yk5s0Q-#dL0%3f`KHEq!(W#~C3za(4{YpAP3QDvI^{G2y>={PF9y>A}tapIwgq^m!Q- z2g1Iw(IMA5Cs)VA{TJ+fPVvL_9C0+7Z#U?7&5X&T7%1Wy#VMUc5MCoLB9skuvDjgS z`0EWLBrm`6D>r_B?A@!6t9#@6V$rGg(CO^xlF0Q7FP7M8HX5_xl>VzUS+E zrSr>4JP^9lXf=ryf}wjZ(j4pw2m8-PX&cuB-R$la$-}kca{Lz*1zk(iQfmrXt6SzN z=$0j|dHLgB_LQuN-t;|VBeZstX+gmpfk$bdAc;`OFR1YtekWgeI8RIj_fEdk``qzu z?*V*}@u0JBMOBq%S4nSh*HeBc^RmiGs^iFWmhl@3KR5EMEQZ7sjcLv*OCM8@?N6(+ zMh%7YhNiWWkyGOi3>-;xEt>OlvlRwY=l%6oOq=EhF~OA$Q1THyvrjdy`&1O(l^&LQ z)%ui`?C*PP>UgF%a(~<&m%y0I46G-{O6DxB4ZK2EpF*|bIn)~wkQK$sF3KZ!PuvaL z`;t^XA6OY>TxRLbGk5(~eOLj-?RxJ@Qja2i7<;DP>a0%+vsAu~WM4xs#rz;Th;f(9 zA(sg+b2x>A_FAHUBwKUp=6K!dY-D2ZgX92HT5Y=>27C)d4wO9rMHn6&=3@{>hd&n_ z1r(kErZgDr3Lp{9;JF+%IN^&xMd9b*9RIC`kEyEzmY-lvzmQ8J28iw`o($;$b2Tk-99;_n*tKjZ5B@3!K9{r~?z`~R#z_u9X1EB@h7jP=K%m^>&r z$0YQSb6^V!69Il4aw$uILTLXg6(Lx4%nDNo>yE>=_&ph%wiU`7_gFG1tQsH>^amLa=&sex`nm3u;tAQu;^TPAvOxN&wKLZFhYS& zmtLD6JyHF2)VsZ|-QKvBr%%+S!v@_7E=i<+qOCf_bwJRgm~|?p!nHWBI(w0=1k+r>O3WfHeoWZPIaZ^`X_K3kW zU-&S8C^idG$&5mTM1YizEUAbl24$F9r6?G}OTfbR#!=vLDa@k;FQ5y#WwW!9Xtj_R z#~fe1((8HNJ8CkAM3Gv!_#2@++R8zNb&t!Tr&S--zb2Mvq&J-`@${~zH4+fdOb)C% z$?16~eQ-_CkVr1`@N7xnBM{irNMYFsV2|l>s=7XA&`%mpp^3!mT~+(CBNODJ&BD2u zZSBXyx57BaSUc@h9u~o=o{?gHYbkksP|}jHp?0aDcXoVZKGI{nLc>Do8oo&ymeR|3 z9RE?K6miACrXMadDTHRiChm%S%D^DK<%~&JK*zmR+z;tYDG`5oLN)BGUl*+jTV^AQ z-Brxz{u|u2ui=~7)DTS8O9N?5HYyH>XgQ|&woVlgxb5RUM|HMVdA?jXP@24@IOWRh z*?<;sLf24F;w_rg$>ih_Zskz=?1ZN6cSg#?il0T4m1ihsOl5Ft($tK$T|cHx64?^w za0`F!DU>!%xT-uxuez;LzPv0`{^To9FzugmW!KSiEA|ft=Vv_Z7lZTDjRi%ar9?!8 z4V_F)0IU!4rVP;i!zlf1^y^0Qhp#ISVEG66`+ms$F9lFpK@v-e@NR?yBj|-tu=@)) z1o$MHva(mRt}a?hHabZYxp?M_O?fq}lNq1bdlR5^b9r4*bB&$%-sfbbe3kxsTBJ&q1d8b+Djq%qr4KGS8%1+Q7R zDPi^E94()J(4Z)+cKb~lQLqn~EA7x8+7a~D@f#!5O@A-LdmW|jgbpf00h3UV>2i{D z+zOQ?uOL45rBSSk-s9PD5VH}*x`H8{q`!h%S;_V?`4$d z9Ct-)<|8#jbq7<#`TKrgP|PPP?t;$A94$?&kFIN|>BF*BNYp)k(EKS^@tA6JQwRGE zVi?1U{PfloO){#sG#_^O0;S6c={|zF+Q;|MYZEr8ST%9GyL}|{w7Hbic(WUFcXjT0 zJ$piI^R9@78gryZ)GV=DCvR=u{qwC^9C|j_leW#)aP7f6DKRvGU~X;N6D+k;b;ao( zJ98A@M|HkW1@bq~gl>7^`O34$E4T8{+mM{4#=4x8Nb;nPsw_xXFkXcRvVM?PHI9N@ zp*cQzt78&(izc0?CVq#6yjMG=1+E zN5&~a4g-cDHpRi~ONqMgZB>;@2V4J2Jvn*tQWlIED@}iRlQPFT z3@C<$e-L&80S1@Y!`4>EDOxNz?yqS>2iNL61-JtKkEO6#O~uv=3JYXJhli0+QpQYfzoOl* zc5qva40hAM%fSrM!aSXk#*2yFh0%nX?I9NcU_s9%(IAr{86_bs1fkvt@qYwE z5MucV?iy%m5B9;|^F5S&0Ea!yQz(rNWP3!U=MsVlA)PYJ;0yj1Z~;eX*ttR_u{f_$ z(}btd9%;jQhzKciVL|qagvFx83tqmbEW)D=EXfg3H4ODE%Gy zD}?sG4R}w1w(J#9^{6wE&Chqck(Vit-CJlEunq%IJDrYXasPZaJNC|U2IDJMGDSjA!r^wPmO4*qdy9@ND)%XCtyj1kmD+o z)1R@?7X`EHkZi*L$LgGw{TZ%qoHkCf9 zpY&b9O#_5dr(mawe_oY(j`;H1F1}zXvGm*|qZdZ$Mqx&QE9|{W6fN=o@%0!A#e&;a z6BPNR1j3W~9up03<=#G-HJxQ9lHh!OJ(;lGdrGp^dJ1n!VXCuEy-v7JuwL^{8K#Tb z;DS{dKR+@dvNTYcdDAgJR7bo&$@T`b`l8E3EBwo3DgKu z*!tM<({0lS)7R5C+4|o;(?+a?(q7lztkq*qN;?=gyk+CZC2^(Ww0YWjJbhfobq?Xj{Hr>YRbiP@@lsKPaw;D`ET|eZjlCU1 zvf6k?$yUnV+@D)Dr=?XUKK+Wjn|HuF&m-fK4v{ZHGa?gb9!H;kpI(Jwm!3q6MhjZg z=Iu_^RrhR9x|Oc6Pk)Hzs&UO|!Td&Tc`?JHYx}+rPr7c^JWjKG^Vm7cIoUPkH47|X zsC#HD%GZz1uGGyzK2zwsTgwfj$C0bBR9;lolTw9?nOdVXqsXIqh)B3cxE~ns9LF7& z8wefa7)=->_1*1rKB#?8TGigY8kU=h+H~!)>6!n?_vyCbnhsS4HBKU;Kd~@jlVA){ z??p&ew-C3kSMy(HjyA7mt`(rTpvvI4 z5MD!xL#e~^BLd+upk1K4JHb1f14x)A^vR!oz=06H5pfOXg=a_7#lCXFW29#*quldo zP;>WncY|Uu5)&2aX_kx`m>7_Vh{BP)ib+hF$i!{Bnm^x6y%oQAulcjdj zGHXtazLPzZj3m#X2-HHXv3#>&E@7JePH7l@<8&>3&31@r@XO$}FS{ALn~Qmy>s`oA zC;NdFN_p^f#naD?@@~4FP0MF(yD>HZ8_7>cL*heGrjHhF!xug%y;7=bGk8{WxX~xv zD6F*H$}p;fV%=+vZM{ElR#R^IIfYDb{LE-*C45DJVlIAnQOif;a(?(cXumc8JpbBl z$ra9RZhpJzi)NaUmfolL6-&D1>%%9xC-u!5du{55It~V?7BMC2z4|AOQ&3yJrWN4QVPHq~wRdEI;MaP6Gwx#_UF*BlmJvR;eZ&nGj9Mu`{%GVZ-k zBhS;)Yu=g5jKz&&zs%sycJn8??{nmF_ju!g-U= zdh~tfBghDts{_V1uY0{YzHOg{+i}=pR6T)VPp;c%x5j&`xl{-Wv{@wr<+oE8GiJrD zr+cqv4903+n8$=Ph%ntJT~;b|Lyr}Y(TTqm-;pSn7>m4&ocF9g?L8WbOqpB_Zl}4c z`y-?J~eKmb36vK7J#eJ^ka6@QeVXlO zj_04x6ftx*w6-(oI^b(EtNOGWJ;q8azT2 zf*RQd>V!`-2y5_{9h=v5)CepzNW@J7;;#t`?VJ-MdzrW+$ zJLydT*6gU&e{$}wJq!NInO^@B-%Z;chTxkIvlB1&2WHs4aq5i3d8H@~QfFru8acA2 zk&QmKoQ&pouV0}RP`%}>AUYu7?|8c#-FKese)|>>QcUEwFomyhEzoT*)W4IweDxaV z(hD1ILwiYHv11_XnB>yn)VKdd}3(*|XgE zS2efivM?yUU|+^O>4IAPgo8TGbu_h^x$mz#y79Epd%A+z$-P4>XdN+-)_j?~zNW)r zFl`@I25NGZsOIH%W4lwqN`&S}aFl1DcHw;WJU4!XG9mWepk(0y=?T~Cgnrl-)|XT) z;oW>3e9RUasdG+cvk|!S(onEuF9R)Nf-NbRJ4P&zQu#HnS ziDeX}ILC`iCw_=mjwff4%_5?9K`0zBq!!aeAxVG=Lru^(qI3)Ar84Jtd%8j{4k1Mn zeG49(@|<551=aEy(&I5iM_IUp&FJ2mEW{_=1gmQh$Rev39aPMsMg}lJ1CI^CIq;jM zNAjC!W^>=2_? z_0-!+%F9+3pQ*_e%2^G*{nD)SDJ<*w>)gP~XBqmg8dTDSrMWf*bcq}SY(5LQv$3Vs z6}+-224~ELsG5z|_7FY3F{i}HdG$SvUp9p>ZDMXo>hP$}peQJ{wIR%x z(cKB7pM%}vDFjkf!Rk@c+1oIM2sKD50}ws!=R*x~ZjyV9D!YO11iNlsh*g-;0R)Q{ zu#m~;=yujb1%Y^W0a4Xdq}Y_53QKHQhNV8tSYDK_NHSJSI9yPn$G7)lyu(V2+~-3d zDPj$X>l)Ez^kPQBiNJ|Wgz<-a=c4RG+&_IaDmMr*TC*kL1;1YAJi>3xM(Wcx)~%i~ zBFQUC??m}>tfv4o*uRH5FrFJ@*(Yqcc`QgR7-?6RNf-|=EG$n`zHF4*gbblMFy17@zJlLn~r?Z z4*3ZuX~<#;9a+<4rW1%vs5}y+%xw)V)0)$2hfQ5Mnp5}97S|3|U@jPLh=s6kfv&W! z{O2609pC~1Q&r#+Um;pxG?wjxdh7OjWWuHJwF2BwJzjDPohM)pKXpuQ=_4e&7vd+) zPO!tzQeuUn4BR%UV+~EiP1X3w;YxLlcTKXFGKZD5{PjyVg5L4%GZkm2(3e$HSU!VKkdYykS!iT3fxnhvbUx1$BtHCw8uLt`of( z&ke~Lm4Twu;A+dX0Ndbe``jyuX{GR}<}%nDwLNXIi*a3llL_Hb5Wk_|#nTIjsTKNT zc?ZPN(IM)Zb|J01gB3|y$81=)4rOKebOYScKHmwrR%+dmHPW6^$O)sfJs4Mlgun@V zm;)h;dBj~q)@Ho({smLiP9AC+y6QnnUbT1fN2Q{K?2 zayQ8jh%H+6nDjGQU}F4WPRQjJhZaXduC-f7iS zwaT8gTnYV+=Q}!K9Mrz*$TM{|j?j(K(sJth#(9_2P%ZY_kNp?Jb!aE>sHGWvBdDQ) z?>`6{M@3kPSR3oUuy|!-!75Ct;4$#_K;?_u;BIv|11DApo}H<&jGZa<$0OzdnFM6E zsRn2j*3ITBEi)Ben-|suW&tM+5Zw8DeKrC0hQV~Nj}kq!y)@VW4T>r}2FTi`>yH8& zYax?giOENf@ft2D?)8ml;|aLjs1o2bk33pg&L)1b+3t`WvVpvL_k4Lc9UTl#tb>*4 z5~(ryU8Z~NC#lnMAiQUayztATlE+-b9BZ2!Xo0|PPmvZkPvauw58ow$gSyvTq>ISs}5(rVbe{Wtf!y0UiK{$c9vdZJR{BALf3+i>)SnMw4`t4 z+EK45Od7RI;Vn!(Po=XR=wJ&DIU$_L1JBmkMQPk&hIC6vW9@#Gs^gUy+t$P!W`iKo zxC(Wk^yzc5fdeIWZJpyD3Fay*%j5Z|>M~gkiu0#ZroB_UJDCe}yCu%Gxy%lF+&uxw z3r*Id_Pz`&P>5Ci2AMYGv&tHr_@4(0_Lt~1TkBDDG+E{#LLAjyq3G64a#>7$oUAsd zLOkEu4<|G>WvRb~hkPn+tw7Z{g zGg^7pAY$(2Wz*{1+B<0oVayuPjc@o$je5;+f)#hMw_~+#&}r$sA+G#M_%;;Q_AW-S z*STM`{W9F*#fIowouat=1Zt4|_*WtKldr-J?m?4Ea4CSXUaaMeI~O0jfb|dmTxRhH#xWyYEG{$>9IE_gACkV^ZYmEV9y!-m0_EXeBh4)TD=8;EHvZJE5 z<^ynJSN>=fcl>Z;cY1JR_{+{%T~2YE+*r#V_fLYX#7TMYvmdt@1lgIK;H*N zz%A>vqjuFUA}%+f%S({9z)0W;uG*t7d8lBO&0 z3+a{!?dCzi)7S8+U*X%)qL;L+(I(j?b=|iZ`>MiUhDPBXcG}n2!>zgviVihZMU7lk zzz?ZO!jSX0I?W5bhVef&nhkC?l56(* zXr@h#FMe2DIT9CwPXTQ~2QPak7{v;V9uud(18bN$x*5$SsbV|GNOQ>V9ss6<*$>pS9GxxBXUxY7lVszUU zMnRn4qfG;8#he-1_$bN*HHYxMZmp>VpUxh@seKI_PT+CnK@$5$RcbxWW8?Fw9n#&< z>74oyGmW>2`XLh&bA(+l0@RIxlwNOMEN*_qenyEy$tvTU&S#^yaDE^`2bmCAauMaAC)cm>t>Jp~oz7+RauGvC1`Eu6i5rOjNZS1;Mor=lYZB`P~7&i zBYq`eoZ@xWA<+uu0h24*s)k!_S$h-h)j?9`c#H|LqjCFY*^S;nu#?cH^V!WYgMa?& z4AgWauIuH1ERBf8=zFTF#kCzoj3dB0{7x-&Itdl|+AM;yM>T-6vt>xX0yz(sO^Tal zSH2J5e!l-I?Z(0*y~1guKBNN0qK&YNDiI|KWjp*$r8uKi2%CtuF1paWk;XT3Y*n711B%B+1mTeU%5!yWM#syLx^?*YP*N(w#$V^% zNIoQZM$-&%rbk|S1VdwbXE_9D#tNT&q3l!11$a`*(mQW1TVSukr4sY@Tx?fPStRve zXWdTuW^#TyV6BtYZ7npd>gq>@Is}A#ZBI?sYTW4`zrUGPki{it)U7q&k7g9kGQgjC zU0&~2!JzZ?OElvBYENIfcj%XAV~4p)LD=~Y5bvBh+EI<+tGKx2JE`-bx|q$K0{}pX zWifak!rXYRycGfSDYE{Mux$+!jeyfKpsZ!gvD74nDO7ulHb!HRaHvpNouoLjKb&4SaBB;}Ng+2JSe-iL?n~jmubuU9Ojj)7k;GLUPc@HmmwuwkwmD z^$PYZNRGB1t?SU`-c17qkia~_<5ekESRASGJv}eGryEtPyYc!_Dk&KWvOL09Yc4HZ zU%le?x1Qx0^9LB;5zJI$XlNQ&y^@&UnX#&CJeFQr@>n~w7>-m>oQ+x-FZOEg<&}vCF?5X1 zE_gdCB&Ylpy4hwU6QeKI2+!Dg8ACJOtW@328o=+W8*!|U>~kY#LZ*`Infg1rrr^uk zfl`Q@s>el`m<0*6ZP6c2Y`klH8JO@Da#)8TIE+w}J?0qo18tLRqq3&*xz1c6cjZ}j zxU(6jG9VCwg|OR z6BET(x@jiT*TNXO!pi$UjdW<0Q>g~6J5(R=?&#-0?2=Q@Q9_nvS_gQBMrUT$trt&m zGDK*PvEJV9SJrVdv?SqbB{A-nD328PZsfX*uY4(MT^-NH$rnu;zMG?ni@Lqcn&M+( zgj3y_AEZERpG&ujIL&4I(8C|gr!2K)1xoJ@Oqg(bp`7=oc>nH(RxZORSe!oI*%I1n z2vY?cC2CgbWv2;rcnmIUugA7truZ5~v){`>V#-#bn89VN+h}_1Rcghg7Zen(t$31$ z3bpdp(0i=$HwpBda+mC%qM{oxO>mJ)>q|wPyO_jANtwA;i&&*Y6>Sv3Uv-!un<6W< z`nwO7JTAA-H6%ofNWr3P?0jkD6gZwQp~i_q3AC+xB5P}8zZyu32$WWOog1C1>5eHy zF4cen4N21?Bqb}9=^tx#rWz;9MvgJYrTT^K2wRr=WvVQO##mdqZAvqHWh;#vKmJQ2 zMS-e=IHUSE+4s9Dh0W8cEjw5?o&}Zs^F^r_?^<~jvghWncXEffVe9bsgpC6DytuV! zOw;?BvIOXS?qp&#)b_*n>SByP$yw$MW0q+jmxj9XXUZ}vaqoxw^mtt2+TX`Q5OtP8 zt_WT8xVpYfOzc|X=v!M7D+l)GC~x1!PnnKPn8blSW00Q-JeWM2={=aB2rnrML|3$l z@r-t=aPU$aAy~fD+yn|K>w{sd<@>z&{U^#d z&fURwZJu`X0WGl=ukCT`z$uvwZe`}9p4Q)c-@|4c`d*90`{C;jBvktq zg}3%=jbB^!GePU+qPQL=6W0(szwstZ=-EXMYa$QiFGAVLf1Wg~$~Trp#ZsqA!$D+ZkGdxo$64Y8^cD`Y3?K|26T1GL^Nbl&2Pd=4G)S`1#ov0SUn zqnAsk7VJ;t-iTK&L)E&yWS9!&aR`lh&4ood4ofSN8$(X+S!O%Da!i_reh-DrzjDrl z!YZ7V73WK$rG{F%vx{!of_%`hp7la7uNsGURWQO}$P#t`i6IP=JnaXI3ZGHC`P+d2 z!doQ=d0V-!AJP%W+tI#|gsCKPtTuXGd#o%M%=-?tB(Y|B@AO`ES@eE>voXuw6S#Txe8+k5NaPnS6DEFY;+ACI^orO~4!212sJ*Pjes+8UN$ z0Q>@c(tKjnPFkLmJi(@~iTl*aJ5nVZC!e$A?p%Vn|3s+==v?_FKzKzdDCwD#mJkhs zbZ7eW=18z2`kf$fw@G-TNGml233o3mFH^m$}QB@QFmSk4!=h)ymz zRsnYL)re5X-hp`?BTz;#Wx=a<&-a=~pynl?@nyimZd2;oLLTF`%&{GH78q1hhlL5p zO93g;<8R_g#OmL@QLKHMf9{^79@?L4!j&+y&&-Vhg$|W5KSW74S*2hDCU71PZuQ)E z6@}K{!~>GQ>SD5seEFlB3U1@;#wX6~Kwhr`j5$43)SSqE1{Q3Wk~^el*hMtVy7h3x zLGp1k zrTDE{f$79hHPRN?YPSw@hI8pa|fRns|2~9`!1ft5ltYAaY6V1Nq6)nfs^=WQ#SfpFcYy z#aHsE3A>0*;`C9>&n!vcROFH>0In zNA4W|8nQWguYtq<0^?fml$A|CZi`8(kA03D%EK}uuijpd(331OaMWOfbwUU;fwFOL zR_N3t641m zZpxSp$#|kxF({A|ir&+H@C^&kQK!*LkV>X}1s%c2ElaC-!x6d1p*Zzwy@-(yms^5C z>gE+yB_*wAgHOI|BIC=EP-KP0(F`JjjEx)#hvJvi-Y*Tus)pmH;`kDARrZ|3JDG&H zOD@%flTWP4uCSy7^+q*KjDkh;r^APc6qLZ3$qC{$sfMa%B5@+l(!DN^4gkvf&e2)8 zY{#Zqa=0F^O(ZcJ$>~TuqjRoPcfEM^{iju87w>PDyZJ?Ig~Jy-YW%u$Z9ZR!jn~&p z&{9&A!c7*&9_Wm=H0VxiY;79~Y`jq_#8s?>zEgPKM59UW-$eJOSOel#2ChqLN!)0{ zo}P-6dr@4r$gntG?(&PqVhhQ4LoGl~I6<~Yg@uK(wRgCzdLD3M{XI9a| z8VyC5?eOdDP99HW)HKv|ElUZ?ZIFN8w7xRGH@|{&OZ;)WIc*U?w%6x^>xn*^gcJTaggdrX)~l)jffH8M*l9IplIQ!y!WIX67Gs<)mI6;HI~_~^QBlsfthM;*`DRLwa)Ad8{bX#{KeZDGQOZ7 zM6`QsNYw)HD6EzUXXtG!Zy{me<9t#%;S%8zF-tM+h*Pu);@7^fnJ1uMyTw)XgfLmd zimyPqMdnRf7*Aa2w<(={>3=;w11#}ANj;ro*-mG%2=9uzVT+PtB1%Z!+=RLN+?Tk> zPbufnTJ3Y`m&Vzm;HJo#yvR*C&qCSiDcj^EOR#C6>NTG?x%e*rT;DS6(BvQDg@4pE z;07}P5x4u9)ct4N?x9GLsHu~&qlLY*9jIQMkdyI4xgJhVX3%>^hW0^@W&M2h=6k^UTP3YOi&d$DYEXT@ z@sKC|{pRni^;gbD00oo3Rqy!5R-j5@-*c-$@nuIRXOU-yjv!VB)lfA2@dXH~b-*NM z3o4svVG9as%NZIg+u0b}{)GHeN{sDiGB>r8v!SsSqq(D@nVGdI%^x!NGijR|^bml8 z3P2MS+GgZntcmA`_&jeO#)n_2IPJiC`nV?FoU}I|m%IuH6a)0XCTGE_An&SR}d}}7h_OmNl=ZjZvYWcLCFWr!S+4vfa%+J&`?Al zs)cAt&f%%Ug00%oeDD~Y8@EryOWdeY3J^TP{ zf51RX#XI#e}OTx0fB$-%goNo^*dfRP=UVR z`ZE9Cm+e7u{uKuY3#g9B-(l>(^9v{YL&>(k_vQMBz7MMWukAP=xbbf=E>`Bh(}096_oGq_-WNzbPV+a%AR2pr8;_5J&hw`~9i& literal 0 HcmV?d00001