diff --git "a/C/book.pdf.txt" "b/C/book.pdf.txt" new file mode 100644--- /dev/null +++ "b/C/book.pdf.txt" @@ -0,0 +1,39903 @@ +Functional C + +Pieter Hartel + +Henk Muller + +January 3, 1999 + + i + +Functional C + +Pieter Hartel +University of Southampton University of Bristol + +Henk Muller + +Revision: 6.7 + + ii + +To Marijke + +Pieter + +To my family and other sources of inspiration + +Henk + +Revision: 6.7 + + c(cid:0) + +1995,1996 Pieter Hartel & Henk Muller, all rights reserved. + +Preface + +The Computer Science Departments of many universities teach a functional lan- +guage as the (cid:2)rst programming language. Using a functional language with its +high level of abstraction helps to emphasize the principles of programming. Func- +tional programming is only one of the paradigms with which a student should +be acquainted. Imperative, Concurrent, Object-Oriented, and Logic programming +are also important. Depending on the problem to be solved, one of the paradigms +will be chosen as the most natural paradigm for that problem. + +This book is the course material to teach a second paradigm: + +imperative pro- +gramming, using C as the programming language. The book has been written so +that it builds on the knowledge that the students have acquired during their (cid:2)rst +course on functional programming, using SML. The prerequisite of this book is +that the principles of programming are already understood; this book does not +speci(cid:2)cally aim to teach ‘problem solving’ or ‘programming’. This book aims to: + +(cid:1) Familiarise the reader with imperative programming as another way of imple- +menting programs. The aim is to preserve the programming style, that is, +the programmer thinks functionally while implementing an imperative pro- +gram. + +(cid:1) Provide understanding of the differences between functional and imperative pro- +gramming. Functional programming is a high level activity. The ordering of +computations and the allocation of storage are automatic. Imperative pro- +gramming, particularly in C, is a low level activity where the programmer +controls both the ordering of computations and the allocation of storage. This +makes imperative programming more dif(cid:2)cult, but it offers the imperative +programmer opportunities for optimisations that are not available to the func- +tional programmer. + +(cid:1) Familiarise the reader with the syntax and semantics of ISO-C, especially the +power of the language (at the same time stressing that power can kill). We +visit all dark alleys of C, from void * to pointer arithmetic and assignments +in expressions. On occasions, we use other languages (like C++ and Pascal) +to illustrate concepts of imperative languages that are not present in C. C has +been chosen because it is a de facto standard for imperative programming, +and because its low level nature nicely contrasts with SML. Those who want +to learn, for example, Modula-2 or Ada-95 afterwards should not (cid:2)nd many +dif(cid:2)culties. + +iii + + iv + +Preface + +(cid:1) Reinforce the principles of programming and problem solving. This is facilitated +by the use of three different languages (mathematics, a functional language, +and an imperative language). The fact that these widely differing languages +have common aspects makes the idea that programming principles exist and +that they are useful quite natural. + +(cid:1) Reinforce the principle of abstraction. Throughout the book we encourage the +student to look for more abstract solutions, for example, by viewing the sig- +nature of a function as an abstraction of its purpose, by using procedural ab- +stractions (in particular higher order functions) early on, and by using data +abstraction. + +(cid:1) Guide the student from speci(cid:2)cation and mathematics to implementation and +software engineering. In the (cid:2)rst chapters the emphasis is on writing correct +functions and as we make progress the emphasis gradually shifts to trans- +forming correct functions into ef(cid:2)cient and reusable functions. Clean inter- +faces are of paramount importance, and are sacri(cid:2)ced for better ef(cid:2)ciency +only as a last resort. + +Each problem in this book is solved in three steps: + +(cid:1) A speci(cid:2)cation of the problem is made. + +(cid:1) An appropriate algorithm is found to deliver solutions that satisfy the speci- + +(cid:2)cation. + +(cid:1) The algorithm is implemented as ef(cid:2)ciently as possible. Throughout the book, + +the emphasis is on this third step. + +The language of mathematics is used to specify the problems. This includes the +basics of set theory and logic. The student should have some familiarity with the +calculi of sets, predicate logic, and propositional logic. This material is taught at +most universities during a (cid:2)rst course on discrete mathematics or formal logic. + +The appropriate algorithm is given in SML. SML is freely available for a range +of platforms (PC’s, UNIX work stations, Apple), and is therefore popular as a teach- +ing language. As many functional languages are not too different from SML, an +appendix gives a brief review of SML for those familiar with any of the other main +stream functional languages, such as Miranda, Haskell, Clean, or Scheme. + +As the target language to implement solutions in an imperative style we have +chosen C. The choice to use C and not C++ was a dif(cid:2)cult one. Both languages +are mainstream languages, and would therefore be suitable as the target language. +We have chosen C because it more clearly exposes the low level programming. To +illustrate this consider the mechanisms that the languages provide for call by refer- +ence. In C, arguments must be explicitly passed as a pointer. The caller must pass +the address, the callee must dereference the pointer. This in contrast with the call by +reference mechanism of C++ (and Pascal and Modula-2). This explicit call by ref- +erence is a didactical asset as it clearly exposes the model behind call by reference, +and its dangers (in the form of unwanted aliases). + +Revision: 6.8 + + Preface + +v + +As this book is intended to be used in a (cid:2)rst year course, only few assumptions +were made about prior knowledge of the students. Reasoning about the correct- +ness of programs requires proof skills, which students might not have acquired at +this stage. Therefore we have con(cid:2)ned all proofs to specially marked exercises. +To distinguish the programming exercises from the exercises requiring a proof, we +have marked the latter with an asterisk. We are con(cid:2)dent that the book can be +used without making a single proof. However we would recommend the students +to go through the proofs on a second reading. The answers to one third of the ex- +ercises are provided in Appendix A. + +The student should have an understanding of the basic principles of comput- +ing. This would include base 2 arithmetic and the principles of operation of the +von Neumann machine. A computer appreciation course would be most appro- +priate to cover this material. The book contains examples from other areas of com- +puter science, including data bases, computer graphics, the theory of program- +ming languages, and computer architecture. These examples can be understood +without prior knowledge of these areas. + +Acknowledgements + +The help and comments of Hugh Glaser, Andy Gravell, Laura Lafave, Denis Nicole, +Peter Sestoft, and the anonymous referees have been important to us. The mate- +rial of the book has undergone its (cid:2)rst test in Southampton in 1995/1996. The (cid:2)rst +year Computer Science students of 1995, and in particular Jason Datt and Alex +Walker have given us a lot of useful feedback. + +We have used a number of public domain software tools in the development +of the book. The noweb literate programming tools of Norman Ramsey, the rail +road diagramming tools from L. Rooijakkers, gpic by Brian Kernighan, TEX, LATEX, +New Jersey SML, and the Gnu C compiler were particularly useful. + +Revision: 6.8 + + vi + +Preface + +Revision: 6.8 + + c(cid:0) + +1995,1996 Pieter Hartel & Henk Muller, all rights reserved. + +Contents + +Preface + +1 + +Introduction +1.1 The functional and the imperative paradigms . +. +. +. +. + +1.1.1 The advantage of state . +. +1.1.2 The advantage of pure functions . +. +1.1.3 +. + +Idiomatic building blocks in C . +. +. +. + +1.2 Guide to the book . + +. +. +. +. + +. +. +. +. + +. + +. + +. + +. + +. + +. + +. + +. + +. + +. + +. + +. + +. + +. + +iii + +1 +1 +3 +3 +3 +4 + +. +. +. +. +. + +. +. +. +. +. + +. +. +. +. +. + +. +. +. +. +. + +. +. +. +. +. + +. +. +. +. +. + +. +. +. +. +. + +. +. +. +. +. + +. +. +. +. +. + +. +. +. +. +. + +. +. +. +. +. + +. +. +. +. +. + +. +. +. +. +. + +2 Functions and numbers + +. + +. + +. + +. + +. + +. + +. + +. + +. + +. + +. + +. + +. + +. + +. + +. + +. + +. + +. + +. + +. + +. + +. + +. + +. + +. + +. + +. + +. +. + +. +. +. + +. +. +. +. +. + +. +. +. +. +. + +. +. +. +. +. +. +. +. +. +. +. +. +. +. + +2.2 Elementary functions . + +2.1 A model of computation . + +Integers +. +. +Logical operators . + +. +2.1.1 A computational model for SML programs . +. +2.1.2 A computational model for C programs . +. +2.1.3 Compiling and executing a C program . +. +. +. + +. +. +. +. +. +. +. +. +. +. +. +. +. +2.2.1 The header of a C function, types and identi(cid:2)ers . +. +. +2.2.2 The body of a C function and its behaviour . +. +. +. +2.2.3 The execution of a C program . +. +. +. +. +. +2.2.4 +. +. +. +. +. +. +2.2.5 +2.2.6 De(cid:2)ning a type for Booleans, typedef and enum . +. +. +. + +7 +7 +. +8 +. +9 +. +. 10 +. 10 +. 14 +. 15 +. 17 +. 18 +. 19 +. 20 +. 21 +. 22 +2.3.1 +2.3.2 +. 26 +. +2.3.3 Differences and similarities between characters and integers . 27 +. 29 +. +. 32 +. 34 +. 34 +. 37 +. 39 +. 44 +. 47 + +. +. +. +. +. +. +. +. +2.5.1 +. +. +. +2.5.2 +2.5.3 An extended example of higher order functions: bisection . +. +. +. +2.6 +. +Summary . +. +. +. +2.7 Further exercises + +. +. +2.4.1 Coercions of integers and (cid:3)oating point numbers . +. +. +. +. +. +. + +2.3 Characters, pattern matching, partial functions . +. +. + +2.5 Functions as arguments +. +. + +Implementing pattern matching in C . +. +. +Partial functions + +Sums . +. +Products . + +2.4 Real numbers . + +. +. +. +. +. +. +. +. +. +. +. +. +. +. + +. +. +. +. +. +. +. +. +. +. +. +. +. +. + +. +. +. +. +. +. +. +. +. +. +. +. +. +. + +. +. +. +. +. +. +. +. +. +. +. +. +. +. + +. +. +. +. +. + +. +. +. +. +. + +. +. +. +. +. + +. +. +. +. +. + +. +. +. +. + +. +. +. +. + +. +. +. + +. +. +. + +. +. +. + +. +. +. + +. +. +. + +. +. +. + +. +. +. + +. +. +. + +. +. +. + +. +. +. + +. +. +. + +. +. +. + +. +. +. + +. +. +. + +. +. +. + +. +. +. + +. +. +. + +. +. +. + +. +. +. + +. +. +. + +. +. +. + +. +. +. + +. +. +. + +. +. +. + +. +. +. + +. +. +. + +. +. +. + +. +. +. + +. +. + +. +. + +. +. + +. +. + +. +. + +. +. + +. +. + +. +. + +. +. + +. +. + +. +. + +. +. + +. +. + +. +. + +. +. + +. +. + +. +. + +. +. + +. +. + +. +. + +. +. + +. +. + +. +. + +. +. + +. +. + +. +. + +. +. + +. +. + +. +. + +. +. + +. +. + +. +. + +. +. + +. +. + +. + +. + +. + +. + +. + +. + +. + +. + +. + +. + +. + +. + +. + +. + +. + +. + +. + +. + +. + +. + +. + +. + +. + +. + +. + +. + +. + +. + +. + +. + +. + +. + +. + +. + +. + +vii + + viii + +3 Loops + +. + +. + +. + +. + +. + +. + +. + +. + +. + +. + +. + +. + +. + +. + +. + +. + +. + +. + +. + +. + +. + +. + +. + +. + +. +. +. +Single argument tail recursion . + +. +3.1 A model of the store . +3.2 Local variable declarations and assignments +. +. +3.3 While loops +. +. +. +3.3.1 +. +3.3.2 Multiple argument tail recursion . +. +. +3.3.3 Non-tail recursion: factorial . +. +. +3.3.4 More on assignments . +. +. +. +Breaking out of while-loops . +3.3.5 +. +. +. +3.4 For loops . +. +. +. +. +. +. +Factorial using a for-loop . +3.4.1 +. +. +. +. +Folding from the right +3.4.2 +3.5 Generalizing loops and control structures . + +. +. +. +. +. +. +. +. +. +. +. +. +. +. +. +. +. +. +. +. +. +. +. +. +3.5.1 Combining foldl with map: sum of squares . +. +3.5.2 Combining foldl with filter: perfect numbers . +. +3.5.3 Nested for statements +. +. +3.6 +. +. +Summary . +. +. +3.7 Further exercises + +. +. +. +. +. +. +. +. +. +. +. +. +. + +. +. +. +. +. +. +. +. +. +. +. +. +. + +. +. +. +. +. +. +. +. +. +. +. +. + +. +. +. +. +. +. +. +. +. +. +. +. + +. +. +. +. +. +. +. +. +. +. +. +. + +. +. +. +. +. +. +. +. +. +. +. +. + +. +. +. +. +. +. +. +. +. +. + +. +. +. +. +. +. + +. +. +. +. +. +. + +. +. +. + +. +. +. + +. +. +. + +. +. +. + +. +. +. + +. +. +. + +. +. +. + +. +. +. + +. +. +. + +. +. +. + +. +. +. + +. +. +. + +. +. +. + +. +. +. + +. +. +. + +. +. +. + +. +. + +. +. + +. +. + +. +. + +. +. + +. +. + +. + +. + +. + +. + +. + +. + +. + +. + +. + +. + +. + +. + +. + +. + +. + +. + +. + +. + +4 Structs and Unions +Structs +. +. +. +Structs in structs . + +. + +. + +. + +. + +. + +. + +. + +. + +. + +. + +. + +. +. + +. +. + +. +. + +. +. + +. +. + +. +. + +. +. + +. +. + +. +. + +. +. + +. +. + +. +. + +. +. +. +. + +. +. +. +. + +. +. +. +. + +. +. +. +. +. + +. +. +. +. +. + +. +. +. +. +. + +. +. +. +. +. + +. +4.1 +4.2 +. +4.3 Unions in structs: algebraic data types . +. + +. +. +. +. +. +. +. +. +. +. +4.3.1 Union types . +4.3.2 +. +Pattern matching: the switch statement +4.3.3 Algebraic types in other imperative languages . +. +. +. +. +. +. +. +. +. +. + +. +. +4.4 Pointers: references to values . +. +. +4.4.1 De(cid:2)ning pointers . +. +. +. +. +4.4.2 Assignments through pointers . +. +. +. +Passing arguments by reference . +4.4.3 +. +Lifetime of pointers and storage . +4.4.4 +. +. +. +4.5.1 The danger of explicit type casts . +4.5.2 Void pointers and parametric polymorphism . +. +. +. +4.6 +. +Summary . +. +. +. +4.7 Further exercises + +4.5 Void pointers: partial application . + +. +. +. +. +. +. +. + +. +. +. +. +. +. +. + +. +. +. +. +. +. +. + +. +. +. +. +. +. +. + +. +. +. +. +. +. +. + +. +. +. +. +. +. +. + +. +. + +. +. + +. +. + +. +. + +. +. + +. +. + +. +. + +. +. + +. +. + +. +. + +. +. + +. +. + +. +. + +. +. + +. +. + +. +. + +. +. + +. +. + +. +. + +. +. + +. +. + +. +. + +. + +. + +. + +. + +. + +. + +. + +. + +5 Arrays +5.1 + +. + +. + +. + +. + +Sequences as a model of linear data structures +. +5.1.1 The length of a sequence . +5.1.2 Accessing an element of a sequence . +5.1.3 Updating an element of a sequence +. +5.1.4 The concatenation of two sequences . +. +. +. +5.1.5 The subsequence . +. +Sequences as arrays in SML . +. +. +5.2.1 Creating an SML array . + +. +. +. + +. +. +. + +. +. +. + +. +. +. + +. +. +. + +. +. +. + +. +. +. + +. + +. + +. + +. +. +. +. +. +. +. +. + +. +. +. +. +. +. +. +. + +. +. +. +. +. +. +. +. + +. +. +. +. +. +. +. +. + +. +. +. +. +. +. +. +. + +. +. +. +. +. +. +. + +5.2 + +. +. +. +. +. +. +. +. +. +. +. +. +. +. +. +. + +. +. +. +. +. +. +. +. + +. +. +. +. +. +. +. +. +. +. +. +. +. +. +. +. + +. +. +. +. +. +. +. +. + +CONTENTS + +. +. +. +. +. +. +. +. +. +. +. +. +. +. +. +. +. + +. +. +. +. +. +. +. +. +. +. +. +. +. +. +. +. + +. +. +. +. +. +. +. +. + +. +. +. +. +. +. +. +. +. +. +. +. +. +. +. +. +. + +. +. +. +. +. +. +. +. +. +. +. +. +. +. +. +. + +. +. +. +. +. +. +. +. + +. +. +. +. +. +. +. +. +. +. +. +. +. +. +. +. +. + +. +. +. +. +. +. +. +. +. +. +. +. +. +. +. +. + +. +. +. +. +. +. +. +. + +. +. +. +. +. +. +. +. +. +. +. +. +. +. +. +. +. + +. +. +. +. +. +. +. +. +. +. +. +. +. +. +. +. + +. +. +. +. +. +. +. +. + +. +. +. +. +. +. +. +. +. +. +. +. +. +. +. +. +. + +. +. +. +. +. +. +. +. +. +. +. +. +. +. +. +. + +. +. +. +. +. +. +. +. + +51 +. 51 +. 53 +. 57 +. 61 +. 64 +. 68 +. 73 +. 75 +. 79 +. 83 +. 86 +. 88 +. 89 +. 91 +. 95 +. 96 +. 98 + +101 +. 101 +. 104 +. 105 +. 106 +. 108 +. 110 +. 112 +. 112 +. 114 +. 116 +. 119 +. 120 +. 125 +. 126 +. 127 +. 129 + +133 +. 134 +. 134 +. 134 +. 135 +. 135 +. 136 +. 136 +. 136 + +Revision: 6.8 + + CONTENTS + +. + +. + +. + +. + +. + +. + +. + +. + +. + +. + +. + +. + +. + +. + +. +. + +. +. + +. +. + +. +. + +. +. + +. +. + +. +. + +. +. + +. +. + +. +. + +. +. + +. +. + +. +. +. + +. +. +. + +. +. +. + +5.3 + +. +. +. +. +. +. +. + +. +. +. +. +. +. +. +. +. +. + +. +. +. +. +. +. +. +. +. +. + +. +. +. +. +. +. +. +. +. +. + +. +. +. +. +. +. +. +. +. +. +. + +. +. +. +. +. +. +. +. +. +. +. + +. +. +. +. +. +. +. +. +. +. +. + +. +. +. +. +. +. +. +. +. +. +. + +5.2.2 The length of an SML array . +. +5.2.3 Accessing an element of an SML array . +5.2.4 Updating an element of an SML array . +. +. +5.2.5 Destructive updates in SML . +. +. +. +. +Sequences as arrays in C . +. +5.3.1 Declaring a C array . +. +. +. +5.3.2 Accessing an element of a C array . +. +5.4 Basic array operations : Arithmetic mean . +. +. +. +5.5 +. +. + +. +. +. +. +. +. +. +. +. +. +. +. +. +. +. +. +. +. +. +. +Strings +. +5.5.1 Comparing strings . +. +5.5.2 Returning strings; more properties of arrays . +. +5.5.3 An application of arrays and strings: argc and argv . +. +. +. +. +. +. +. +. +. +. +. +. + +. +. +. +. +. +Explicit versus implicit memory management +. +Ef(cid:2)ciency aspects of dynamic memory . +. +. +. +. +. +. +. +. +. +. + +5.6 Manipulating array bounds, bound checks +. +5.7 Dynamic memory . +. +5.7.1 The allocation of dynamic arrays . +5.7.2 The extension of dynamic arrays . +5.7.3 The deallocation of dynamic arrays +5.7.4 +5.7.5 +. +5.8 +Slicing arrays: pointer arithmetic . +5.9 Combining arrays and structures . +. +5.10 Multi-dimensional arrays with (cid:2)xed bounds +. +. +. +5.11 Summary . +. +. +5.12 Further exercises + +. +. +. +. +. +. +. +. +. +. +. +. + +. +. +. +. +. +. +. +. +. +. +. +. + +. +. +. +. +. +. +. +. +. +. +. +. + +. +. +. +. +. +. +. +. +. +. +. +. + +. +. +. +. +. +. + +. +. +. +. +. +. + +. +. +. +. +. + +. +. +. +. +. + +. +. +. +. +. + +. +. +. +. +. + +. +. +. +. +. + +. +. +. +. +. + +. +. +. + +. +. + +. +. + +. +. + +. +. + +. +. + +. +. + +. +. + +. +. + +. +. + +. +. + +. +. + +. +. + +. +. + +. +. + +. +. + +. +. + +. +. + +. +. + +. +. + +. + +. + +. + +. + +. + +. + +. + +. + +. + +. + +. + +. + +. + +. + +6 Lists + +. + +. + +. + +. + +. + +. + +. + +. + +. + +. + +. + +. + +. + +. + +. + +. + +. + +. + +. + +. + +. + +. + +. + +. +. + +. +. + +6.1.1 + +. +. +. +. +. +. +. +. +. + +6.5 Open lists + +6.1 Lists of characters . + +. +Filtering elements from a list + +. +. +. +List access functions: head and tail . +. +. +. +. + +6.4.1 Appending two lists . +6.4.2 +6.4.3 Mapping a function over a list +. +. +. + +. +. +. +. +. +6.2 The length of a list +. +. +. +. +6.3 Accessing an arbitrary element of a list . +. +6.4 Append, (cid:2)lter and map: recursive versions . +. +. +. +. +. +. +. +. +. +6.5.1 Open lists by remembering the last cell +. +6.5.2 Open lists by using pointers to pointers . +. +6.5.3 Append using open lists . +. +. +. +. +. +. +. +. + +. +. +6.6.1 Converting an array to a list . +. +From a list to an array . +6.6.2 +. +6.7 Variable number of arguments +. +. +Store reuse . +6.8 +. +. +. +. +. +Summary . +6.9 +. +. +6.10 Further exercises + +6.6 Lists versus arrays + +. +. +. +. +. +. +. +. + +. +. +. +. +. +. +. +. + +. +. +. +. +. +. +. +. + +. +. +. +. +. +. +. +. + +. +. +. +. +. +. +. +. + +. +. +. +. +. +. +. +. + +. +. +. +. +. + +. +. +. +. +. + +. +. +. +. + +. +. +. +. + +. +. +. +. + +. +. +. + +. +. +. + +. +. +. + +. +. +. + +. +. +. + +. +. +. + +. +. +. + +. +. + +. +. + +. +. + +. + +. + +. + +. + +. + +. + +. + +. + +. + +. + +. + +. + +. + +. + +. + +. + +. + +. + +. + +. +. +. +. +. +. +. +. +. +. +. +. +. +. +. +. +. +. +. + +. +. +. +. +. +. +. +. +. +. +. +. +. +. +. +. +. +. +. + +. +. +. +. +. +. +. +. +. +. +. +. +. +. +. +. +. +. +. + +. +. +. +. +. +. +. +. +. +. +. +. +. +. +. +. +. +. +. + +. +. +. +. +. +. +. +. +. +. +. +. +. +. +. +. +. +. +. + +. +. +. +. +. +. +. +. +. +. +. +. +. +. +. +. +. +. +. + +. +. +. +. +. +. +. +. +. +. +. +. +. +. +. +. +. +. +. + +. +. +. +. +. +. +. +. +. +. +. +. +. +. +. +. +. +. +. + +ix + +. 137 +. 137 +. 137 +. 138 +. 138 +. 138 +. 139 +. 139 +. 142 +. 143 +. 144 +. 146 +. 147 +. 152 +. 153 +. 155 +. 159 +. 161 +. 162 +. 163 +. 168 +. 174 +. 175 +. 176 + +181 +. 181 +. 183 +. 185 +. 186 +. 186 +. 186 +. 188 +. 190 +. 191 +. 193 +. 195 +. 197 +. 198 +. 199 +. 201 +. 204 +. 206 +. 208 +. 210 + +. +. +. +. +. +. +. +. +. +. +. +. +. +. +. +. +. +. +. +. +. +. +. +. + +. +. +. +. +. +. +. +. +. +. +. +. +. +. +. +. +. +. +. + +. +. +. +. +. +. +. +. +. +. +. +. +. +. +. +. +. +. +. +. +. +. +. +. + +. +. +. +. +. +. +. +. +. +. +. +. +. +. +. +. +. +. +. + +. +. +. +. +. +. +. +. +. +. +. +. +. +. +. +. +. +. +. +. +. +. +. +. + +. +. +. +. +. +. +. +. +. +. +. +. +. +. +. +. +. +. +. + +Revision: 6.8 + + CONTENTS + +x + +7 Streams + +. + +. + +. + +. + +. + +. + +. + +. + +. +. +. + +. +. +. + +. +. +. +. +. + +7.1 Counting sentences: stream basics + +. +IO in C: opening (cid:2)les as streams . + +7.1.1 +7.1.2 Avoiding the intermediate list . +7.1.3 + +. +Ef(cid:2)ciently transferring a stream to a list . +. +. +. + +. +. +. +. +. +. +7.2 Mean sentence length: how to avoid state . +. +7.3 Counting words: how to limit the size of the state . +. +. +. +. +. +. +. +. +. + +7.3.1 Using a sliding queue . +7.3.2 +7.3.3 +. +7.3.4 Counting words using arrays . +. +. +. +7.4.1 Quicksort on the basis of lists . +. +7.4.2 Quicksort on the basis of arrays . +. +. +. +7.5 +. +Summary . +. +. +. +7.6 Further exercises + +. +Implementing the sliding queue in SML . +. +Implementing the sliding queue in C . +. +. +. +. +. +. +. +. +. +. +. +. + +7.4 Quicksort . + +. +. +. +. +. +. +. +. +. + +. +. +. +. +. +. + +. +. +. +. +. +. + +. +. +. +. +. +. + +. +. + +. +. + +. +. + +. +. + +. +. + +. +. + +. +. + +. +. + +. +. + +. +. + +. + +. + +. + +. + +. + +. + +. + +. + +. + +. + +. + +. + +. + +. + +. + +. + +. + +. + +. + +. + +. + +. + +. + +. + +. + +. + +. +. +. +. +. +. +. +. +. +. +. +. +. +. +. + +. +. +. +. +. +. +. +. +. +. +. +. +. +. +. + +. +. +. +. +. +. +. +. +. +. +. +. +. +. +. + +. +. +. +. +. +. +. +. +. +. +. +. +. +. +. + +. +. +. +. +. +. +. +. +. +. +. +. +. +. +. + +. +. +. +. +. +. +. +. +. +. +. +. +. +. +. + +. +. +. +. +. +. +. +. +. +. +. +. +. +. +. + +. +. +. +. +. +. +. +. +. +. +. +. +. +. +. + +. +. +. +. +. +. +. +. +. +. +. +. +. +. +. + +8 Modules + +. + +. + +. + +. + +. + +. + +. + +. + +. + +. +. +. + +. +. +. + +. +. +. +. + +. +. +. +. +. + +. +. +. +. +. + +8.2.1 +8.2.2 + +8.2 Compiling modules . + +8.1 Modules in C: (cid:2)les and the C preprocessor +. +. +. + +. +. +Simple modules, #include . +. +. +8.1.1 +. +. +8.1.2 Type checking across modules +. +8.1.3 Double imports . +. +. +. +8.1.4 Modules without an implementation . +8.1.5 The macro semantics of #define directives +. +. +. +. +. +. +. +Separate compilation under UNIX . +. +Separate compilation on other systems +. +. +. + +. +. +. +. +. +. +. +. +. +. +. +. +8.3.1 Random number generation, how to use a global variable . +. +8.3.2 Moving state out of modules . +. +8.3.3 +. +. +. +. + +. +Scoping and life time of global and local variables . +. +. +. +. +. +. +. +. + +8.4 Abstract Data Types . +8.5 Polymorphic typing . +. +8.6 +. +Summary . +. +8.7 Further exercises + +8.3 Global variables . + +. +. +. +. +. +. +. +. +. +. + +. +. +. +. +. +. +. +. +. +. + +. +. +. +. +. +. +. +. +. +. + +. +. +. +. +. +. +. +. +. +. + +. +. +. +. +. +. +. +. +. +. + +. +. +. +. +. +. +. +. +. +. + +. +. +. +. +. +. +. +. +. +. + +. +. +. +. +. +. +. +. +. +. + +. +. +. +. +. +. + +. +. +. +. +. +. + +. +. +. +. +. +. + +. +. +. +. +. +. + +. +. +. +. + +. +. +. +. + +. +. +. +. + +. +. +. +. + +. +. +. +. + +. +. +. +. + +. +. +. +. + +. +. +. +. + +. +. +. +. + +. +. +. +. + +. +. +. +. + +. +. +. +. + +. +. +. +. + +. +. +. +. + +. +. +. +. + +. +. +. +. + +. +. +. +. + +. +. +. +. + +. +. +. +. + +. +. +. +. + +. +. +. +. + +. +. +. +. + +. +. + +. +. + +. + +. + +. + +. + +. + +. + +. + +. + +. + +. + +. + +. + +. + +. + +. + +. + +. + +. + +. + +. + +. + +. + +. + +. + +. + +. + +. + +. + +. + +. + +. + +. + +. + +. + +. + +. + +9 Three case studies in graphics + +9.1 First case study: drawing a fractal + +. +. + +. +. + +Shortening the argument lists . +. + +. +. +. +. +9.1.1 De(cid:2)ning the Mandelbrot set . +. +. +9.1.2 Drawing the fractal on the screen . +. +. +9.1.3 +9.1.4 Handling events +. +. +. +Second case study: device independent graphics . +. +. +. +. +. +9.2.1 +. +9.2.2 Monolithic interface design . +. +. +9.2.3 Modular interface design . + +PostScript + +. +. +. +. +. + +. +. +. +. +. + +. +. +. +. +. + +. +. +. +. +. + +. +. +. + +. +. +. + +. +. +. + +. +. +. + +. +. +. + +. +. +. + +. +. +. + +. +. + +. + +. + +. + +. + +. + +. + +. + +. + +. + +. + +. + +. + +. + +. +. +. +. +. +. +. +. +. + +. +. +. +. +. +. +. +. +. + +. +. +. +. +. +. +. +. +. + +. +. +. +. +. +. +. +. +. + +. +. +. +. +. +. +. +. +. + +. +. +. +. +. +. +. +. +. + +. +. +. +. +. +. +. +. +. + +. +. +. +. +. +. +. +. +. + +. +. +. +. +. +. +. +. +. + +. +. +. +. +. +. +. +. +. + +9.2 + +Revision: 6.8 + +213 +. 214 +. 216 +. 218 +. 219 +. 222 +. 224 +. 225 +. 226 +. 228 +. 231 +. 234 +. 235 +. 236 +. 242 +. 243 + +245 +. 246 +. 246 +. 250 +. 251 +. 253 +. 253 +. 255 +. 255 +. 263 +. 263 +. 263 +. 266 +. 268 +. 269 +. 272 +. 276 +. 278 + +283 +. 283 +. 284 +. 286 +. 292 +. 294 +. 299 +. 299 +. 300 +. 302 + + xi + +. 307 +. 309 +. 312 +. 315 +. 316 +. 316 + +321 +. 321 +. 337 +. 347 +. 353 +. 362 +. 372 +. 380 +. 389 + +391 +. 391 +. 392 +. 394 +. 394 +. 395 +. 397 +. 398 +. 401 + +403 +. 403 +. 405 +. 406 +. 407 +. 408 +. 408 +. 409 + +411 + +CONTENTS + +9.3 Third case study: a graphics language . +. +. +. +. +. + +Lexical analysis . +9.3.1 +. +Parsing . +. +9.3.2 +. +Interpretation . +9.3.3 +. +. +. +. +Summary . +9.4 +. +. +9.5 Further exercises + +. +. +. +. +. + +. +. +. +. +. + +. +. +. +. +. + +. +. +. +. +. + +. +. +. +. +. + +. +. +. +. +. + +. +. +. +. +. + +. +. +. +. +. + +. +. + +. +. + +. + +. + +. + +. + +. + +A Answers to exercises + +Answers to the exercises of Chapter 2 . +Answers to the exercises of Chapter 3 . +Answers to the exercises of Chapter 4 . +Answers to the exercises of Chapter 5 . +Answers to the exercises of Chapter 6 . +Answers to the exercises of Chapter 7 . +Answers to the exercises of Chapter 8 . +Answers to the exercises of Chapter 9 . + +. +. +. +. +. +. +. +. + +. +. +. +. +. +. +. +. + +. +. +. +. +. +. +. +. + +B A brief review of SML + +. +. +. +. +. +. + +. +. +. +. +. +. +. +. + +. +. +. +. +. +. + +. +. +. +. +. +. +. +. + +B.1 About the four main functional languages . +B.2 Functions, pattern matching, and integers . +. +. +B.3 Local function and value de(cid:2)nitions . +. +B.4 Reals, booleans, strings, and lists . +. +. +. +B.5 Type synonyms and algebraic data types +. +. +B.6 Higher order functions . +. +. +. +B.7 Modules . +. +. +. +B.8 Libraries . + +. +. +. + +. +. +. + +. +. +. + +. +. +. + +. +. +. + +. +. +. + +. +. +. + +. +. +. + +. +. +. + +. +. + +. +. + +. +. + +. +. + +. +. + +. +. + +. +. + +. +. + +. + +C Standard Libraries + +. + +. + +. + +. + +. +. + +. +. +. +. + +. +C.1 Standard I/O . +. +. +C.2 Strings +. +C.3 Character classes +C.4 Mathematics . +. +. +C.5 Variable argument lists . +. +C.6 Miscellaneous . +. +C.7 Other modules . + +. +. +. +. + +. +. +. +. + +. +. + +. +. + +. +. + +. +. + +. + +. +. +. +. +. +. +. + +. +. +. +. +. +. +. + +. +. +. +. +. +. +. + +. +. +. +. +. +. +. + +. +. +. +. +. +. +. + +. +. +. +. +. +. +. + +. +. +. +. +. +. +. + +. +. +. +. +. +. +. + +. +. +. +. +. +. +. + +. +. +. +. +. +. +. + +. +. +. +. +. +. +. + +. +. +. +. +. +. + +. +. +. +. +. +. +. +. + +. +. +. +. +. +. +. +. + +. +. +. +. +. +. +. + +. +. +. +. +. +. + +. +. +. +. +. +. +. +. + +. +. +. +. +. +. +. +. + +. +. +. +. +. +. +. + +. +. +. +. +. +. + +. +. +. +. +. +. +. +. + +. +. +. +. +. +. +. +. + +. +. +. +. +. +. +. + +. +. +. +. +. +. + +. +. +. +. +. +. +. +. + +. +. +. +. +. +. +. +. + +. +. +. +. +. +. +. + +. +. +. +. +. +. + +. +. +. +. +. +. +. +. + +. +. +. +. +. +. +. +. + +. +. +. +. +. +. +. + +. +. +. +. +. +. + +. +. +. +. +. +. +. +. + +. +. +. +. +. +. +. +. + +. +. +. +. +. +. +. + +. +. +. +. +. +. + +. +. +. +. +. +. +. +. + +. +. +. +. +. +. +. +. + +. +. +. +. +. +. +. + +. +. +. +. +. +. + +. +. +. +. +. +. +. +. + +. +. +. +. +. +. +. +. + +. +. +. +. +. +. +. + +. +. +. +. +. +. + +. +. +. +. +. +. +. +. + +. +. +. +. +. +. +. +. + +. +. +. +. +. +. +. + +. +. +. +. +. +. + +. +. +. +. +. +. +. +. + +. +. +. +. +. +. +. +. + +. +. +. +. +. +. +. + +. +. +. +. +. +. + +. +. +. +. +. +. +. +. + +. +. +. +. +. +. +. +. + +. +. +. +. +. +. +. + +. +. +. +. +. +. + +. +. +. +. +. +. +. +. + +. +. +. +. +. +. +. +. + +. +. +. +. +. +. +. + +. +. +. +. +. +. + +. +. +. +. +. +. +. +. + +. +. +. +. +. +. +. +. + +. +. +. +. +. +. +. + +. +. +. +. +. +. + +. +. +. +. +. +. +. +. + +. +. +. +. +. +. +. +. + +. +. +. +. +. +. +. + +D ISO-C syntax diagrams + +Gnu C-compilerTM is a trademark of Free Software Foundation. +IBM PCTM is a trademark of IBM. +MacintoshTM is a trademark of Apple Computer, Inc. +MirandaTM is a trademark of Research Software Ltd. +UNIXTM is a trademark of Novell. +PostscriptTM is a trademark of Adobe Systems, Inc. +TEXTMis a trademark of the American Mathematical Society. +X Window SystemTM is a trademark of the MIT. + +Revision: 6.8 + + xii + +CONTENTS + +Revision: 6.8 + + c(cid:0) + +1995,1996 Pieter Hartel & Henk Muller, all rights reserved. + +Chapter 1 + +Introduction + +Programming is the activity of instructing a computer so that it will help to +solve a problem. These instructions can be prepared on the basis of a number of +paradigms. This book has been written for those who are familiar with the func- +tional paradigm, using SML as a programming language, and who wish to learn +how to program in the imperative paradigm, using C as a programming language. + +1.1 The functional and the imperative paradigms + +The functional and imperative paradigms operate from different viewpoints. The +functional paradigm is based on the evaluation of expressions, and binding variables +to values. The basic program phrase is the expression; the purpose of evaluating +an expression is to produce a value. The order in which subexpressions are evalu- +ated does not affect the resulting values. + +The imperative paradigm is based on the execution of statements, and having a +store where the statements can leave their results. The basic program phrase is the +statement; the purpose of executing a statement is to change the store. The order +in which statements are executed does affect the resulting values in the store. The +current set of values in the store is referred to as the state of the program. + +The reasons for these different approaches lie in the roots of the languages +based on these paradigms. Functional languages were developed coming from +mathematics. The foundation of these languages is therefore clean and well under- +stood. Imperative languages were designed coming from the machine operational +point of view: The von Neumann architecture has a memory and a processor op- +erating on this memory. The imperative paradigm is a high level abstraction of +this model. + +Functional and imperative languages can be used to program in either style: it +is possible to write an imperative program in SML, and it is also possible to write +a functional program in C. However, these programs are often ‘unnatural’, in that +their formulation is clumsy because the language does not offer the most appro- +priate abstractions. + +As an example, consider the classical problem of generating pseudo random + +numbers. This is how we can formulate this problem functionally in C: + +1 + + 2 + +Chapter1. Introduction + +int functional_random( int seed ) { + +return 22 * seed % 37 ; + +} + +The functional implementation should be read as follows: the (cid:2)rst line introduces +a function by the name of functional_random. This function accepts an integer +argument called seed and it also returns an integer value. The function body (en- +closed in curly brackets { and }) contains a single return statement. The argument +of the return statement is an expression, which multiplies the value of seed by 22 +and then yields the remainder after division by 37. + +To use the function functional_random, one has to choose a suitable start +value for the seed, for example 1, and then repeatedly apply the function +functional_random. Successive pseudo random values will then be obtained. +Consider the following C program fragment: + +int first = functional_random( 1 ) ; +int second = functional_random( first ) ; +int third = functional_random( second ) ; + +The value of the variable first will be 22; the value of the variable second will +be 3, (because 22*22 (cid:0) 13*37+3) and the value of third will be 29. + +The function functional_random is a pure function, that is the value re- +turned by each call of functional_random depends exclusively on the value of +its argument. This implies that functional_random will always give the same +answer when it is called with the same argument value. A pure function is there- +fore a good building block. + +The pseudo random number generator can also be written in an imperative + +style: + +int seed = 1 ; +int imperative_random( void ) { + +seed = 22 * seed % 37 ; +return seed ; + +} + +The imperative implementation should be read as follows: the (cid:2)rst line de(cid:2)nes a +global variable, called seed, which holds the current seed value. The initial value is +1. The next line introduces a function by the name of imperative_random. The +function has no arguments, which is indicated by the word void. The function +changes the value of seed, and returns its value after having made the change. +The modi(cid:2)cation of the store is referred to as a side effect, because it was an effect +additional to returning the pseudo random number. + +That this function is imperative becomes clear when we ‘mentally’ execute +the code. The (cid:2)rst call to imperative_random will return 22, whereupon the +variable seed has the value 22. This will cause the function to return 3 on the +next call. So on every invocation, the function imperative_random will re- +turn a new value, which is exactly what we require from a pseudo random num- +ber generator. The order of calls becomes important, as the value returned by +imperative_random now depends on the state, and not on its argument. + +Revision: 6.19 + + 1.1. Thefunctionalandtheimperativeparadigms + +3 + +Both paradigms have their advantages. The imperative paradigm makes it eas- +ier to deal with state, as the state does not have to be communicated from one +function to the other, it is always present. The functional paradigm allows us to +create building blocks that can be used more freely. We will elaborate on these +issues below. + +1.1.1 The advantage of state + +A useful extension of the random function would be to build a function that re- +turns the value of a dice. The value of a dice can be computed by taking the ran- +dom number modulo 6, and adding one to it, which will return a value in the +range 1 . . . 6. The imperative function for the dice would read: + +int imperative_dice( void ) { + +return imperative_random() % 6 + 1 ; + +} + +A random number is generated, the modulo operation is performed, and one is +added. Writing the functional version is more dif(cid:2)cult, two numbers have to be +returned from this function: the value of the dice and the state of the random num- +ber generator. The caller of the functional dice would have to take one of the num- +bers, and remember to pass the next on to the next call. + +1.1.2 The advantage of pure functions + +Storing state somewhere in a hidden place has a disadvantage: it becomes more +dif(cid:2)cult to create functions that can be used as neat building blocks. As an exam- +ple, assume that we would like to roll two dice every time. The theory of random +number generators tells us that it is incorrect to use alternate numbers from one +random number generator to generate the values of the two dice [5]. Instead, two +independent random generators must be used. + +The functional version offers a random generator that can be used as a building +block, supposing that the initial seeds where stored in r and s, then the following +fragment of code will generate a value for the two dice: + +int x = functional_random( r ) ; +int y = functional_random( s ) ; +int dice = x%6 + 1 + y%6 + 1 ; + +It is impossible to achieve this with the imperative version, because there is only +one variable seed which stores the seed. + +1.1.3 Idiomatic building blocks in C + +Ideally, we would like to have the best of both worlds. The reader can look ahead +to Chapter 8 to see a random number generator, which is a good building block, +and which passes the state around in a manner that scales well beyond a single +function. + +Revision: 6.19 + + 4 + +Chapter1. Introduction + +This is the aim of this book: we wish to create highly idiomatic and ef(cid:2)cient C +code, but also wish to create good building blocks, preserving all the techniques +that are common knowledge in the world of functional languages. Examples in- +clude pure functions, polymorphic functions, currying, algebraic data types and +recursion. + +1.2 Guide to the book + +The next chapter discusses the basic execution model of C. The basic syntax and +data types are also presented. In that chapter a declarative subset of C is used. +This does not result in idiomatic or ef(cid:2)cient C programs, but it serves to familiarise +the reader with the basic syntax of C. Chapter 2 also introduces the (cid:2)rst systematic +transformation of functional code into C. + +Chapter 3 discusses iteration. Functional languages iterate over data structures +by means of direct recursion or by means of indirect recursion through higher or- +der functions such as map and foldl. C offers constructions that iterate with- +out recursion by repeatedly executing certain parts of the program code. In Chap- +ter 3 we create ef(cid:2)cient and idiomatic C for most example programs of Chapter 2. +This is done using a number of systematic, but informal, program transformation +schemas. + +Chapter 4 discusses the type constructors of C that are necessary to build (non +recursive) algebraic data types. These constructors are called structures and unions. +The chapter discusses how to create complex types and ends with a discussion on +destructive updates in these data structures (using a pointer). + +The (cid:2)rst 4 chapters discuss the basic data types and their C representation. +More complex data types can store sequences data. There are a number of repre- +sentations for storing sequences. In functional languages, lists are popular; arrays +are used when ef(cid:2)cient random access is required to the elements. Lists are less +popular in C because the management of lists is more work than the management +of lists in functional languages. Sequences, arrays, lists, and streams are discussed +in Chapters 5 to 7. + +Chapter 5 presents the basic principles of sequences and the implementation of +arrays. Arrays in C are at a low level, but it is shown that high level structures, as +available in functional languages, can be constructed. Lists are discussed in Chap- +ter 6. The implementation of lists requires explicit memory management; this is +one of the reasons that using lists is less convenient in C than in SML. The stream, +a list of items that are consumed or written sequentially (as in I/O), are the topic +of Chapter 7. + +Chapter 8 (cid:2)nally goes into details of how the module system of C works, com- +paring it to the module system of SML. Modular programming is the key issue in +software engineering. De(cid:2)ning interfaces in such a way that modules have a clear +function and the proper use of state are the subjects of this chapter. + +The last chapter, Chapter 9, shows three case studies in elementary graphics. +The (cid:2)rst case is completely worked out, it shows how to use an X-window system +for drawing a fractal for the Mandelbrot set. The second case study is partially + +Revision: 6.19 + + 1.2. Guidetothebook + +5 + +worked out, it designs a system for device independent graphics. There are large +parts left to be implemented by the reader. The third study develops an imple- +mentation for a simple graphics language. The algorithms are outlined, and the +data structures are sketched, the implementation of this case is left to the reader. + +Appendix A contains the answers to a selection of the exercises. The exercises +give readers the opportunity to test and improve their skills. There are two types +of exercises. The normal exercises reinforce the general skills of problem solving. +Many of them require an implementation of some SML code, and almost all of +them require the implementation of some C functions. The exercises marked with +an asterisk are targeted at readers who are interested in the fundamental issues of +programming. All proofs of the theorems that we pose are left as an ‘exercise(cid:0) ’ to +the reader. + +Appendix B is a brief review of SML for people familiar with other functional +languages. It suf(cid:2)ces that people can read SML programs. We only discuss the +subset of SML that we use in the book and only in terms of other functional lan- +guages. This appendix also discusses the (small set of) SML library functions that +we use. + +Appendix C lists the library functions of C. All programming languages come +with a collection of primitive operators and data types as well as a collection of +library modules providing further facilities. C is no exception and has a large set of +libraries. We present a small number of functions that are present in the C library. +The last Appendix D gives the complete syntax of ISO-C using railroad dia- +grams. These are intuitively clearer than the alternative BNF notation for syntax. +The syntax diagrams are intended as a reference. + +This book is not a complete reference manual. The reader will thus (cid:2)nd it use- +ful to be able to refer to the ISO-C reference manual [7]. It contains all the details +that an experienced C programmer eventually will have to master and that an in- +troductory text such as this one does not provide. + +Revision: 6.19 + + 6 + +Chapter1. Introduction + +Revision: 6.19 + + c(cid:0) + +1995,1996 Pieter Hartel & Henk Muller, all rights reserved. + +Chapter 2 + +Functions and numbers + +Functional programming in SML and imperative programming in C have much in +common. The purpose of this chapter is to show that, when given an SML solu- +tion to a problem, a C solution can often be found without much dif(cid:2)culty. The +C solutions presented here are not necessarily the best from the point of view of +their ef(cid:2)ciency, but will be a good starting point for the further re(cid:2)nements that +are presented in later chapters. In the present chapter, we emphasise the differ- +ences between computation as perceived by the mathematician and computation +as carried out on computers. We support this by introducing a model of computa- +tion, and we illustrate the concepts by solving a number of sample problems. + +The (cid:2)rst problem that will be solved is to compute the greatest common divisor +of two natural numbers. This example discusses in some detail the representation +of integral numbers and the C syntax to denote functions. The second example +computes the values of arithmetic expressions. It serves to discuss the differences +between pattern matching, as it is commonly found in functional languages, and +conditionals. The third example calculates an integral power of a real number. It +uses (cid:3)oating point numbers. This example is used to discuss the ins and outs of +representing reals in C. The fourth example uses higher order functions to com- +pute sums and products. With some extra effort, this powerful abstraction can be +used in C programs, albeit in a slightly limited setting. + +2.1 A model of computation + +A programmer solves a problem by writing a computer program. The answer to +the problem is then the result produced by the program. First and foremost, the +programmer must understand the problem that is being solved. The programmer +must also have an understanding of the way in which computers work, for a pro- +gram is merely an instruction to the computer to carry out particular computa- +tions in a particular order. Without such an understanding, the programmer may +attempt to instruct a computer to do things that it cannot do without exceeding the +given resources, or worse, the programmer might attempt to make the computer +do things that it cannot do at all. Compared to the human brain, computers are +rather limited in what they can do. On the other hand, a computer can do certain + +7 + + 8 + +Chapter2. Functionsandnumbers + +tasks more quickly and more accurately than the human brain. A computational +model is a basic understanding of the kind of things that a computer can do and +how it does them. We will formulate two such models, one that is applicable when +we write SML programs and another that applies when we write C programs. + +2.1.1 A computational model for SML programs + +An SML program consists of a number of function de(cid:2)nitions and a main expres- +sion. Computation is the process of (cid:2)nding the value of the main expression. In all +but trivial programs, the evaluation of the main expression will cause subsidiary +expressions to be evaluated until no more expressions remain whose values are +required. The SML programmer needs to know about this computational process +for a number of reasons. + +Firstly, the process is started with the main expression, so this must be given as + +part of the program. + +Secondly, the main expression will make use of certain functions (either pre- +de(cid:2)ned or user de(cid:2)ned), so these de(cid:2)nitions must be available to the computer. +These function de(cid:2)nitions may make use of further functions, if so these must be +given also. The program is complete only if all required de(cid:2)nitions are given. + +The SML programmer also needs to know how an expression is evaluated. As- +sume that an expression consists of a function name and a list of argument values +to which that function is applied. The mechanism involved in evaluating the ex- +pression consists of four steps: + +(cid:1) The de(cid:2)nition of the named function is looked up in the list of known func- + +tion de(cid:2)nitions. + +(cid:1) The formal arguments of the function de(cid:2)nition are associated with the val- + +ues provided by the actual arguments of the function. + +(cid:1) The body of the function is examined to yield a further expression that can be +evaluated now. This includes evaluation of the arguments, where necessary. + +(cid:1) As soon as all subsidiary expressions are evaluated, the result of the function +is returned. The value of this result only depends on the values of the actual +arguments of the function. + +The mechanism of starting with a given expression, activating the function it men- +tions, and looking for the next expression to evaluate comprises the computational +model that underlies an implementation of SML. Knowledge of this mechanism +enables the programmer to reason about the steps taken whilst the program is be- +ing executed. The programmer will have to make sure that only a (cid:2)nite number of +such steps are required, for otherwise the program would never yield an answer. +In most circumstances, the programmer will also try to make sure that the least +number of steps are used to (cid:2)nd an answer, as each step takes a certain amount of +time. + +Revision: 6.47 + + 2.1. Amodelofcomputation + +9 + +Reasoning about the behaviour of a program is an important aspect of pro- +gramming, and it is this computational model that gives the programmer the tool +to perform such reasoning. + +2.1.2 A computational model for C programs + +To some extent it is possible to write C programs in a functional style, such that +the computational model that we sketched above for SML is applicable. How- +ever, this has two important drawbacks. Firstly, the resulting C programs would +be rather inef(cid:2)cient, and secondly, a programmer trained to read and write C pro- +grams written in a functional style would not be able to read C programs written +by other programmers, as they would be using the language in a way that is not +covered by the computational model. + +In this chapter, we introduce a simpli(cid:2)ed computational model for C programs +which is almost the same as that for SML. In the next chapter, we will add a model +of the store, so as to expand the simple model to a full computational model of C +programs. + +In the simple computational model, a C program is a list of function declara- +tions. One of the functions should have the name main. This function plays the +same role as the main expression of an SML program. In the simple model, ex- +pressions are evaluated as for SML. The difference is that in C functions consist +not of pure expressions but of statements. A statement is an operation on the state +of the program, by executing statements in the right order, the program achieves +its result. In this chapter we will only use three statements: + +(cid:1) The return-statement terminates the execution of a function and returns a + +result value. + +(cid:1) The expression-statement evaluates an expression, ignoring the result. To +contribute to the computation, the expression will often have a side effect. A +side effect refers to any result which is not returned as the value of the ex- +pression but which ends up somewhere else, printing output on the screen +for example. Purely functional languages do not allow side effects. + +(cid:1) The if-statement conditionally executes other statements. + +In the coming chapters, we will gradually introduce all statements of C. We will +not use any state in this chapter, the concept of the store is introduced in Chapter 3. +The following C program demonstrates a simple program: + +/* A simple C program, it prints (cid:145)Hello World(cid:146) */ +int main( void ) { + +printf( "Hello world\n" ) ; +return 0 ; + +} + +The text between a (cid:147)/*(cid:148) and a (cid:147)*/(cid:148) is comment, and ignored by the C compiler. +The (cid:2)rst statement of the function main is: +printf( "Hello world\n" ) ; + +Revision: 6.47 + + 10 + +Chapter2. Functionsandnumbers + +This statement returns no useful value; +Hello world as a side effect. The second statement is: + +its sole purpose is to print the text + +return 0 ; + +The execution of this statement results in the value 0 to be delivered as the value of +the expression main( ). The main program above shows that the body of a func- +tion in C consists of a number of statements. The computational model prescribes +that these statements are obeyed in the order in which they are written. + +2.1.3 Compiling and executing a C program + +Once the C program is written, it needs to be compiled and executed. Here we +give a minimal introduction how to compile a program, which is stored in a single +(cid:2)le. The compilation of multi module programs is dealt with in Chapter 8. On +UNIX systems (or one of its equivalents such as LINUX, AUX, AIX, and so on), +the C program must be stored in a (cid:2)le with a name that ends on .c. The program +can then be compiled by invoking the C compiler, cc: + +cc -o monkey hello.c + +This will compile the program hello.c. Any errors are reported, and if the com- +piler is satis(cid:2)ed with the code, an executable (cid:2)le, monkey in this case, is created. +The program can be executed by typing monkey: + +Hello world + +Newer systems, such as Macintoshes or PC’s often offer integrated environments +such as the Codewarrior or Borland C. From within the editor, the compiler can +be called, and the program can be executed. It is impossible to give an exhaustive +description of all these systems, local manuals should be consulted on how to edit, +compile and execute programs on these systems. + +2.2 Elementary functions + +We are now ready to study an interesting algorithm. The greatest common divisor +(gcd) of two positive natural numbers is the largest natural number that exactly +divides both numbers. The gcd of 14 and 12 is 2, while the gcd of 14 and 11 is 1. +The gcd of two numbers is given by the speci(cid:2)cation: + +(cid:1)(cid:3)(cid:2) + +(cid:4)(cid:6)(cid:5)(cid:7)(cid:2) + +(cid:4)(cid:9)(cid:8)(cid:11)(cid:10) + +gcd (cid:0) + +(cid:1)(cid:13)(cid:12)(cid:7)(cid:14)(cid:16)(cid:15)(cid:17)(cid:8) + +(cid:4)(cid:30)(cid:29)(cid:31)(cid:12) + +gcd + +(cid:18)(cid:20)(cid:19)(cid:22)(cid:21)(cid:24)(cid:23)(cid:26)(cid:25)(cid:28)(cid:27) + +(cid:18)! #"$(cid:25) + +&%(’ + +(cid:18)! #"(cid:28)(cid:25) + +)%+* + +(2.1) + +The standard algorithm for calculating the gcd follows Euclid’s method. If, for two +positive natural numbers +is +, we have that +de(cid:2)ned by: + +, then the gcd of + +and + +and + +(cid:12)-,)(cid:15) + +(cid:1).(cid:2) + +(cid:4)(cid:6)(cid:5)(cid:7)(cid:2) + +(cid:4)/(cid:8)(cid:11)(cid:10) + +euclid (cid:0) + +(cid:1)(cid:13)(cid:12)(cid:7)(cid:14)(cid:16)(cid:15)(cid:17)(cid:8) + +euclid + +(cid:1)1(cid:15)2(cid:14)(cid:16)(cid:12) + +(cid:15)3(cid:8)(cid:16)(cid:14) + +(cid:15)(cid:7), + +euclid + +(cid:18)! #" + +(cid:12)(cid:7)(cid:14) + +if +otherwise + +(2.2) + +Revision: 6.47 + +(cid:2) +(cid:4) +(cid:0) +(cid:2) +(cid:0) +(cid:15) +(cid:0) +(cid:12) +(cid:15) +(cid:12) +(cid:15) +(cid:2) +(cid:4) +(cid:0) +0 +% + 2.2. Elementaryfunctions + +11 + +This can be written directly in SML: + +(* euclid : int -> int -> int *) +fun euclid m n = if n > 0 + +then euclid n (m mod n) +else m ; + +The following lines show the results of applying the euclid function to a set of +sample arguments: +euclid 14 12 +euclid 14 11 +euclid 558 198 = 18 ; + += 2 ; += 1 ; + +We will now give a ‘transformation recipe’ for creating a C function from an SML +function. Such a recipe, of which we shall present several more, makes it possible +to transform SML into C code systematically. This is important because, if we start +with a tried and tested SML function, then a good C function should result from +a systematic transformation. Basically, this means that one has to think only once +whilst creating a functional solution, and then follow the recipe carefully to create +a good C implementation. + +To be able to give a transformation recipe, it is necessary to capture the essen- +tial aspects of the function to be transformed. Such a capture is called a schema. +Each recipe will consist of two schemata: one to capture the SML function and one +to capture the corresponding C function. The two schemata together can then be +used to do the transformation. Here is the SML version of the function schema: +(*SML function schema*) + +(* (cid:0) : (cid:1)(cid:3)(cid:2) -> ... (cid:1)(cid:5)(cid:4) -> (cid:1)(cid:7)(cid:6) *) +fun (cid:0)(cid:9)(cid:8)(cid:10)(cid:2) ... (cid:8)(cid:11)(cid:4) += if (cid:12) + +then (cid:13) +else (cid:14) ; + +This schema looks a bit complicated because it tries to cater for as general a class +of functions as possible. In particular, the notation (cid:8)(cid:15)(cid:2)(cid:17)(cid:16)(cid:18)(cid:16)(cid:18)(cid:16)(cid:19)(cid:8)(cid:20)(cid:4) represents just a sin- +gle (cid:8) as well as any particular number +of (cid:8) -es. The symbols in italic font in the +function schema are to be interpreted as follows: + +(cid:1) The symbolic name (cid:0) + +Any concrete function name may be substituted for (cid:0) + +stands for the name of the function to be captured. +, for example euclid. + +(cid:1) The number + +gives the number of arguments of the function (cid:0) + +. + +(cid:1) The (cid:8)(cid:10)(cid:2)(cid:10)(cid:16)(cid:21)(cid:16)(cid:18)(cid:16)(cid:22)(cid:8)(cid:20)(cid:4) are the arguments of (cid:0) + +. + +(cid:1) The (cid:1)(cid:3)(cid:2)(cid:23)(cid:16)(cid:18)(cid:16)(cid:18)(cid:16)(cid:22)(cid:1)(cid:7)(cid:4) are the types of the arguments (cid:8)(cid:24)(cid:2)(cid:17)(cid:16)(cid:18)(cid:16)(cid:21)(cid:16)(cid:22)(cid:8)(cid:20)(cid:4) respectively. + +(cid:1) The type of the function result is (cid:1)(cid:22)(cid:6) . + +(cid:1) The expression (cid:12) + +is a predicate in (cid:8) + +(cid:16)(cid:18)(cid:16)(cid:18)(cid:16)(cid:3)(cid:8) + +(cid:4) . + +(cid:1) The expressions (cid:13) and (cid:14) are expressions involving the values (cid:8)(cid:25)(cid:2)(cid:23)(cid:16)(cid:18)(cid:16)(cid:21)(cid:16)(cid:3)(cid:8)(cid:20)(cid:4) . + +Revision: 6.47 + +(cid:15) +(cid:15) +(cid:2) + 12 + +Chapter2. Functionsandnumbers + +The C version of the function schema, which corresponds exactly to the function +schema in SML above, is: +/*C function schema*/ + +(cid:4) ) { + +(cid:0) ( (cid:1) +if ( (cid:12) ) { + +(cid:2) , ... (cid:1) + +return (cid:13) ; + +} else { + +return (cid:14) ; + +} + +} + +The symbols in this schema are to be interpreted as above, with the proviso that +the various syntactic differences between SML and C have to be taken care of in a +somewhat ad-hoc fashion. + +Identi(cid:2)ers in SML may contain certain characters that are not permitted in +C. These characters must be changed consistently. The requirements for C +identi(cid:2)ers are discussed later on page 13. + +(cid:1) The basic types in SML are generally the same as in C, but some must be +changed. For example, real in SML becomes double in C. A list of basic +types is given at the end of this chapter. + +(cid:1) Many of the operators that appear in SML programs may also be used in C + +programs. The operators of C are discussed in Section 2.2.4 + +(cid:1) Curried functions are not permitted in C, so the arguments to all function + +calls must be supplied. + +Let us now apply the function schema to the function euclid. Below is a ta- +ble of correspondence which relates the schema, the SML program and the C pro- +gram. The (cid:2)rst column of the table contains the relevant symbolic names from the +schema. In the second column, we put the expressions and symbols from the SML +function. The third column contains a transformation of each of the elements of +the SML function into C syntax. + +Schema Functional + +: +(cid:1)(cid:3)(cid:2) : +(cid:1)(cid:1)(cid:0) : +(cid:1)(cid:7)(cid:6) : +(cid:2) : +(cid:0) : +: +: +: + +euclid +int +int +int +m +n +n > 0 +euclid n (m mod n) euclid( n, m%n ) +m + +C +euclid +int +int +int +m +n +n > 0 + +m + +Revision: 6.47 + +(cid:1) +(cid:6) +(cid:2) +(cid:8) +(cid:4) +(cid:8) +(cid:1) +(cid:0) +(cid:8) +(cid:8) +(cid:12) +(cid:13) +(cid:14) + 2.2. Elementaryfunctions + +13 + +The creation of the C version of euclid is now simply a matter of gathering the +information from the third column of the table and substituting that information +in the right places in the C function schema. This yields: + +int euclid( int m, int n ) { + +if( n>0 ) { + +return euclid( n, m%n ) ; + +} else { + +return m ; + +} + +} + +The process of transforming an SML function into C is laborious but not dif(cid:2)cult. +We shall often tacitly assume that all the steps in the transformation have been +made and just present the net result of the transformation. + +The euclid example has been chosen because there is a C implementation that +is close to the mathematical and the functional versions. The C implementation of +euclid is shown below, embedded in a complete program. + +#include + +int euclid( int m, int n ) { + +if( n>0 ) { + +return euclid( n, m%n ) ; + +} else { + +return m ; + +} + +} + +int main( void ) { + +printf( "%d\n", euclid( 14, 12 ) ) ; +printf( "%d\n", euclid( 14, 11 ) ) ; +printf( "%d\n", euclid( 558, 198 ) ) ; +return 0 ; + +} + +This program shows the following lexical conventions of C: + +(cid:1) As in SML, the indentation in the program is chosen by the author of the +program. The program layout re(cid:3)ects the program structure. A space can be +necessary to separate two tokens, but there is no difference between a single +space or a number of spaces and newlines. + +Identi(cid:2)ers in C consist of a sequence of letters (the case of the letters is signif- +icant), underscores ((cid:147)_(cid:148)), and digits. The (cid:2)rst symbol of an identi(cid:2)er must be +either a letter or an underscore. Valid identi(cid:2)ers are, for example, monkey, +Monkey, ___123, or an_id_13. + +The C version of the euclid program starts with an include directive: + +#include + +Revision: 6.47 + +(cid:1) + 14 + +Chapter2. Functionsandnumbers + +This directive tells the compiler to include the text from the (cid:2)le stdio.h at this +point. This is necessary for the program to be able to use most input and output +facilities. The include directive and many others are discussed in Chapter 8 (on +modules); for now this directive will just be used in every program that is written. +After the include directive, two functions are de(cid:2)ned: euclid and main. +Each of the functions consists of a function header, de(cid:2)ning the type of the func- +tion result and the name and type of the function arguments, and a function body, +enclosed in curly brackets, de(cid:2)ning the behaviour of the function. The function +headers, the function body, and the execution of this C program are discussed in +turn below. + +2.2.1 The header of a C function, types and identi(cid:2)ers + +The header of the (cid:2)rst C function in the program is: + +int euclid( int m, int n ) + +The de(cid:2)nition of the function euclid starts with the de(cid:2)nition of the type of the +value that the function will return. In this case, the type is int which is short for +the type of integer numbers. The SML equivalent of this type is also int. + +After the type of the function, the function name is speci(cid:2)ed (euclid) and +then, between parentheses, the types and names of the arguments of the function +are given. In this function there are two arguments. The (cid:2)rst argument is of type +int and is named m, and the second argument (after the comma) is again of type +int and is named n. The argument names m and n are used to refer to the (cid:2)rst and +second argument in the body of the function. + +The declaration of main is: + +int main( void ) + +This header declares that the function with the name main will return an int +value. The argument list is speci(cid:2)ed to be void, which means that the function +main has no arguments. + +In C, every function must be declared before it can be used. As the function +main refers to euclid, euclid must be de(cid:2)ned before main. De(cid:2)ning the func- +tions in the other order might work (if the C compiler manages to guess the types +of the function correctly), but it is bad practice to rely on this. + +There are cases where both functions call each other, so-called mutually recur- +sive functions. In this case, neither function can be de(cid:2)ned (cid:2)rst. The solution that +C offers is the function prototype. A prototype is like a type signature in SML: it +declares a function and its type, but does not de(cid:2)ne the internal details. After +the prototype is de(cid:2)ned, the function can be used. The function can be de(cid:2)ned +completely later on. A function prototype consists of the header of the function +followed by a semicolon. Thus the prototypes of the two functions above are: + +int euclid( int m, int n ) ; +int main( void ) ; + +In most functional languages, types are automatically inferred by the compiler. It +is good functional programming style to always specify the types of functions, so + +Revision: 6.47 + + 2.2. Elementaryfunctions + +15 + +that the compiler can check the user speci(cid:2)ed types against its own inferred types. +Any mismatch points out errors in the program. In C, the programmer must spec- +ify all types. + +2.2.2 The body of a C function and its behaviour + +After the de(cid:2)nition of the types of the function and its arguments, the code of the +function is de(cid:2)ned. In an imperative language, this code consists of a sequence of +statements. A statement is a command to perform some kind of operation. As is +shown in detail in Section 2.2.3, a function is evaluated by evaluating each state- +ment in turn. + +In C, each statement is terminated with a semicolon. A number of statements +that are logically one statement can be grouped by enclosing the statement group +in curly brackets. The body of a function is a group of statements, enclosed +in curly brackets. The function euclid contains two kinds of statements: +the +return statement and the if statement. + +A return statement is used to terminate the execution of the function and to +calculate the return value of the function. The return value is de(cid:2)ned by the ex- +pression between the return and the semicolon terminating the statement. + +An if statement has the general form: + +if( (cid:12) ) { + +} else { + +} + +, else execute the statements (cid:1) + +This can be read as follows: if the conditional expression (cid:12) evaluates to true, exe- +cute the statements (cid:0) +. We generally use upper case +italic letters to indicate where statements may occur. Upon completion of (cid:0) or (cid:1) +, +any statements following the if statement are executed. In the case of euclid, +there are no statements following the if statement. The if statement above can +also be used without the optional else part: + +if( (cid:12) ) { + +} + +If the else part is omitted, the C program will just continue with the next state- +ment if the conditional expression (cid:12) evaluates to false. The curly brackets { and } +are used to group statements. They can be omitted if there is only one statement +between them, but we will always use them to make it easier to modify programs +later on. + +Expressions in C are like functional expressions except that they use a slightly +different syntax. For example, the arguments of a function must be separated +by commas, and they must be enclosed in brackets. Therefore the function ap- +plication f x y in the functional language is written in C as f(x,y). The op- +is denoted in C as x%y. +erators have also different syntax: for example, (cid:8) + +(cid:18)! #" + +(cid:3)(cid:2) + +Revision: 6.47 + +(cid:0) +(cid:1) +(cid:0) + 16 + +Chapter2. Functionsandnumbers + +Most other operators have their usual meaning (a full list is given shortly in Sec- +tion 2.2.4). This information is suf(cid:2)cient to interpret the body of the function +euclid: + +{ + +if( n>0 ) { + +return euclid( n, m%n ) ; + +} else { + +return m ; + +} + +} + +If n is greater than zero, execute the then part: + +return euclid( n, m%n ) ; + +Else, if n is not greater than zero, execute the else part: + +return m ; + +The (cid:2)rst of these two statements orders the function to return, more speci(cid:2)cally to +deliver, the value of the expression euclid( n, m%n ) as the function’s return +value. The second of the statements orders to return the value of m (in this case, +the value of n equals 0). + +The keyword else of the if statement in this particular function is redundant. + +Consider the two statements: + +{ + +} + +if( n>0 ) { + +return euclid( n, m%n ) ; + +} +return m ; + +The (cid:2)rst of these, the if statement, will execute the statement below if n is greater +than zero: + +return euclid( n, m%n ) ; + +If the return is executed, the function is terminated without executing any more +statements. Thus the second statement, return m, is only executed if n is equal +to zero. We will come back to redundant else statements in the next section. + +The body of the main function contains 4 statements. The (cid:2)rst statement is: + +printf( "%d\n", euclid( 14, 12 ) ) ; + +It is a call to the function printf. This call has two arguments: the (cid:2)rst argument +is a string "%d\n", and the second argument is the value that is returned after +calling euclid with arguments 14 and 12. As we will see shortly, this call to +printf will print the value of euclid( 14, 12 ) + +The next two statements in the body of main are similar to the (cid:2)rst: the sec- +ond statement prints the greatest common divisor of the numbers 14 and 11, and +the third prints the greatest common divisor of the numbers 558 and 198. The +last statement returns the value 0 to the calling environment of the program. This +issue will be discussed in more detail in the next paragraphs. + +Revision: 6.47 + + 2.2. Elementaryfunctions + +17 + +2.2.3 The execution of a C program + +The execution of every C program starts by calling the function with the name +main. Thus, every C program should have a function called main. Apart from +the name, the type of the arguments and the type of the return value of main are +special. Main should always return an int, and if there are arguments for main, +they should follow the syntax discussed in Chapter 8, which deals with the envi- +ronment. For now, all main functions will be without arguments and will always +return the value 0. This value will be interpreted by the environment as ‘every- +thing all right, the program completed satisfactorily’. + +Upon execution of main, the (cid:2)rst statement of the program has to be executed. +In the case of the example program, this is a call to printf. The C language re- +quires that all arguments of a function must be evaluated before the function is +called, similar to the strict evaluation of SML. The values of the arguments are then +passed to the function. This mechanism is known as call by value. Another way to +pass arguments, call by reference, is discussed in Chapter 4. + +The (cid:2)rst argument passed to printf, the string "%d\n", is a constant, so it + +does not need to be evaluated. The second argument is the expression: + +euclid( 14, 12 ) + +This expression represents a function call that has to be evaluated (cid:2)rst. However, +before euclid can be executed, its arguments have to be evaluated. These argu- +ments are constants (the integers 14 and 12) so euclid is executed directly, with +m having the value 14 and n having the value 12. Eventually when euclid re- +turns a value, the printf will be invoked. + +The (cid:2)rst statement of euclid tests if n is greater than 0. Since this is true, +the then statement is executed. This will in turn call the function euclid with +arguments 12 and 14%12, which is 2. Therefore, euclid is called again with m +equal to 12 and n equal to 2. + +The (cid:2)rst statement of euclid tests again if n is greater than 0. This is true, so +the then statement is executed. This will cause the function euclid to be called +with arguments 2 and 12%2, which is 0. Thus euclid is called with m equal to 2 +and n equal to 0. + +The (cid:2)rst statement of euclid tests again if n is greater than 0. Since this is +not true, the else-statement is executed, which causes the function to return m, +which will return the value 2. This value is returned in turn by each of the pre- +vious invocations of euclid, and will eventually turn up in the main function in +which the arguments of printf are now fully evaluated to give: + +printf( "%d\n", 2 ) ; + +The function printf is called, it will print the (cid:2)rst argument to the output; how- +ever, it handles percent signs in a special manner. Every time printf encounters +a %d, it replaces the %d with a decimal representation of the integer that is taken +from the argument list. In this example, the value printed is 2, which was just cal- +culated. The \n results in a newline, just like SML. The resulting output is there- +fore: +2 + +Revision: 6.47 + + 18 + +Chapter2. Functionsandnumbers + +This completes the execution of the (cid:2)rst statement of main. Upon completion of +this (cid:2)rst statement, the next statement of main is executed. Again this is a call to +printf. The (cid:2)rst argument of this function is a constant string, and the next ar- +gument is again a call to the function euclid, this time with arguments 14 and +11. Euclid is invoked with m equal to 14 and n equal to 11. Instead of giving an- +other lengthy explanation of which function calls which function, a trace of func- +tion calls can be given as follows: + +euclid( 14, 11 ) calls + +euclid( 11, 3 ) calls + +euclid( 3, 2 ) + +euclid( 2, 1 ) + +euclid( 1, 0 ) +1 + +calls + +calls +is + +The chain of calls will return the value 1, which is printed by the main program. +Exercise 2.1 How many times is the function euclid called when executing the + +third statement of main? + +2.2.4 Integers + +The euclid example works with integer numbers, which are captured by the C +type int. There are many ways to denote integer constants in C. The most com- +mon form is to use the decimal representation, as already used before. 13 stands +for the integer 13. A minus sign can be used to denote negative values, as in -13. +A second option is to specify numbers with a different base, either base 8 or base +16. Hexadecimal values (using base 16) can be speci(cid:2)ed by writing them after the +letters 0x. So 0x2C and 44 both refer to the same number. Octal numbers (with +base 8) should begin with the digit 0. So 0377, 0xFF and 255 all specify the same +number. + +The operators that can be applied to integers are listed below, together with + +their SML and mathematical equivalents: + +Unary + +Binary + +C ++ +- +˜ +* +/ +% ++ +- +<< +>> +& +| +ˆ + +SML + +Math Meaning + +˜ + +* +div, / +mod ++ +- + +div , + +(cid:18)! #" + +Unary plus +Unary minus +Bitwise complement +Multiplication +Division +Modulo +Addition +Subtraction +Bitwise shift left, (cid:8) << (cid:3) +Bitwise shift right, (cid:8) >> (cid:3) +Bitwise and +Bitwise or +Bitwise exclusive or + +Revision: 6.47 + +(cid:8)(cid:5)(cid:4)(cid:7)(cid:6)(cid:9)(cid:8) + +(cid:6)(cid:9)(cid:8) + +(cid:0) +(cid:5) +(cid:1) +(cid:2) +(cid:0) +(cid:0) +(cid:0) +(cid:0) +(cid:0) +(cid:8) +(cid:1) + 2.2. Elementaryfunctions + +19 + +There is one group of operators that does not have an SML equivalent: the bit +operators. Bit operations use the two’s-complement binary interpretation of the +integer values. The ˜ operator inverts all bits, the &, | and ˆ operators perform a +bit-wise and, or, and exclusive-or operation on two bit patterns. The following are +all true: + +(˜0) == -1, + +(12 & 6) == 4, +(12 | 6) == 14, +(12 ˆ 6) == 10 + +The << and >> operations shift the bit pattern a number of positions: x<>j shifts y by j positions to the right. Some +examples: + +(12 << 6) == 768, +(400 >> 4) == 25 + +Bit operations can be supported ef(cid:2)ciently because all modern computer systems +store integers bitwise in two’s-complement form. + +The type int is only one of a multitude of C types that can be used to manipu- +late integer values. First of all, C supports the unsigned int type. The keyword +unsigned implies that values of this type cannot be negative. The most impor- +tant feature of the unsigned int type is that the arithmetic is guaranteed to be +modulo-arithmetic. That is, if the answer of an operation does not (cid:2)t in the domain, +the answer modulo some big power of 2 is used. Repeatedly adding one to an +unsigned int on a machine with 32-bit integers will give the series % , (cid:0) , (cid:6) , . . . +(cid:6)(cid:3)(cid:2)(cid:5)(cid:9) , % , (cid:0) , . . . . Modulo arithmetic is useful in situations where +longer arithmetic (128-bit numbers, for example) is needed. Other types of inte- +gers will be shown shortly, in Section 2.3.3. + +, (cid:1) + +(cid:2)(cid:5)(cid:4)(cid:7)(cid:6) + +(cid:2)(cid:5)(cid:4)(cid:8)(cid:6) + +(cid:6)(cid:5)(cid:2) + +(cid:6)(cid:5)(cid:2) + +(cid:6)(cid:3)(cid:2) + +2.2.5 Logical operators + +The language C does not have a separate type for booleans, instead integers are +used to represent booleans. The comparison operators, listed below, result in the +integer value 1 or 0; 1 is used to represent true and 0 is used to represent false. + +SML +< + +C +< +<= <= +>= >= +> +> +== = +!= <> + +Math Meaning +Less than +Less than or equal +Greater than or equal +Greater than +Equal +Not equal + +C provides the three usual logical operators. They take integers as their operands, +and produce an integer result: + +Revision: 6.47 + +(cid:1) +(cid:1) +(cid:1) +(cid:1) +(cid:10) +(cid:11) +(cid:12) +, +(cid:0) +(cid:13) +(cid:0) + 20 + +Chapter2. Functionsandnumbers + +Math Meaning + +SML +not + +C +! +&& andalso ’ +|| orelse + +Logical not, !0==1, !x==0 (if x!=0) +Logical and +Logical or + +The ! operator performs the logical negation (not) operation, !0 is 1 and !1 is 0. +In addition the negation operator in C accepts any non zero value to mean true, so +!153 is 0. + +The && operator performs the logical conjunction (and) and the logical disjunc- + +tion operator (or) is ||. Some truth relations of these operators are: + +(0 && x) == 0, +(1 && x) == x, +(0 || x) == x, +(1 || x) == 1 + +The logical && and || both accept any non-zero value to mean true, like the ! op- +erator. The operation of the && and || operators is identical to their SML equiva- +lents, but different to their counterparts in some other imperative languages. Con- +sider the following expression: + +x != 0 && y/x < 20 + +This expression tests (cid:2)rst if x equals zero. If this is the case, the rest of the ex- +pression is not evaluated (because 0&& (cid:16)(cid:18)(cid:16)(cid:18)(cid:16) is 0). Only if x does not equal zero, the +inequality, y/x < 20 is evaluated. This behaviour is called short circuit semantics. +A similar comparison in Pascal would be: + +(x <> 0) AND (y/x < 20) + +The semantics of Pascal are such that this leads to disaster if x equals zero, as +(y/x < 20) is evaluated regardless of whether x equals zero or not. + +Do not confuse the operators &&, || and == with their single equivalents &, | +and =. The operators & and | are bit-operators, and the single equal sign, =, be- +haves different from the ==. It will be discussed in the next chapter. Accidentally +using a = instead of a ==, results probably in a program that is syntactically correct +but with different behaviour. It can be hard to discover this error. + +The last logical operator that C supports is the ternary if-then-else operator, +which is denoted using a question mark and colon: c?d:e means if c evaluates +to a non-zero value, the value of d is chosen, else the value of e is chosen. + +2.2.6 De(cid:2)ning a type for Booleans, typedef and enum + +The of(cid:2)cial way to denote the truth values in C is 0 and 1, but to have a clear struc- +ture for a program involving logical operations, it is often convenient to introduce +a type for booleans. The following line at the beginning of a program takes care of +that: + +typedef enum { false=0, true=1 } bool ; + +This line consists of logically two parts. The outer part is + +typedef (cid:0) + +bool ; + +Revision: 6.47 + +(cid:0) +(cid:1) + 2.3. Characters,patternmatching,partialfunctions + +21 + +The keyword typedef associates a type (cid:0) with a typename, bool in this case. +The type can be any of the builtin types (int for example), or user constructed +types such as enum { false=0, true=1 }. The keyword enum is used to de- +(cid:2)ne an enumerated type. The domain spans two elements in this case, false and +true, where false has the numeric value 0 and true has the numeric value 1. +The general form of an enumerated type is: + +enum { (cid:0)(cid:2)(cid:1) , (cid:0) + +(cid:5)(cid:2) , (cid:0) + +(cid:0) ... } + +(cid:5)(cid:2) , (cid:0) + +The (cid:0)(cid:2)(cid:1) , (cid:0) +(cid:0) , (cid:16)(cid:21)(cid:16)(cid:18)(cid:16) are the identi(cid:2)ers of the domain. The identi(cid:2)ers are represented +as integers. The identi(cid:2)ers can be bound to speci(cid:2)c integer values, as was shown +in the de(cid:2)nition of the type bool. The combination of typedef with enum has a +counterpart in SML: +/*C combination of typedef and enum*/ + +typedef enum { (cid:0)(cid:3)(cid:1) , (cid:0) + +(cid:5)(cid:2) , (cid:0) + +(cid:0) ... } (cid:1) ; + +(*SML scalar datatype declaration*) + +datatype (cid:1) = (cid:0)(cid:3)(cid:1) | (cid:0) + +(cid:5)(cid:2) | (cid:0) + +(cid:0) ... ; + +The following C fragment de(cid:2)nes an enumerated type language: + +typedef enum { Japanese, Spanish, Chinese } language ; + +This is equivalent to the following SML declaration: + +datatype language = Japanese | Spanish | Chinese ; + +2.3 Characters, pattern matching, partial functions + +The data types integer and boolean have now been discussed at some length, so +let us examine another useful data type, the character. The character is a standard +scalar data type in many languages, including C. Interestingly, the character is not +a standard data type in SML. Instead, SML offers strings as a basic data type. In +all languages that offer characters as basic data types, strings occur as structured +data types, that is, as data types built out of simpler data types. Structured data +types will be discussed in detail in Chapter 4 and later chapters. To overcome the +slight oddity of SML we will assume that an SML string containing precisely one +element is really a character. The SML type char will be de(cid:2)ned as follows: + +type char = string ; + +As an example of a function that works on characters, consider the speci(cid:2)cation +below for evaluating an expression. Suppose an expression that consists of three +integers and two operators (either (cid:146) +(cid:146) ) has to be evaluated. The rules +(cid:146) or (cid:146) +for operator precedence state that multiplication takes precedence over addition, +as indicated in the speci(cid:2)cation below. Here, the set (cid:4) represents all possible char- +acters. + +(cid:6)(cid:5) + +(cid:146)+(cid:146) + +(cid:146)*(cid:146) + +Revision: 6.47 + +(cid:2) +(cid:5) +(cid:8) +(cid:14) +(cid:2) +(cid:14) +(cid:0) +(cid:2) +(cid:4) +(cid:14) +(cid:0) +(cid:4) + 22 + +Chapter2. Functionsandnumbers + +(cid:146)+(cid:146) +(cid:146)+(cid:146) +(cid:146)*(cid:146) +(cid:146)*(cid:146) + +(cid:146)+(cid:146) +(cid:146)*(cid:146) +(cid:146)+(cid:146) +(cid:146)*(cid:146) + +Using pattern matching on the operators, we can write a function to evaluate an +expression with addition and multiplication operators as follows: + +(* eval : int -> char -> int -> char -> int -> int *) +fun eval x "+" y "+" z = (x + y) + z +| eval x "+" y "*" z = x + (y * z) +| eval x "*" y "+" z = (x * y) + z +| eval x "*" y "*" z = (x * y) * z : int ; + +The function eval takes 5 arguments: 3 integers and 2 characters. The integers +are represented as the value of x, y, and z, and the two characters specify which +operations to perform. Pattern matching is used to decide which of the four al- +ternatives to choose. Pattern matching leads to clear and concise programs and, +as a general rule, one should thus prefer a pattern matching programming style. +However, C does not support pattern matching, instead, pattern matching has to +be implemented using if statements. + +2.3.1 Implementing pattern matching in C + +As a preparation to implementing eval in C, consider how it could be imple- +mented in SML using conditionals. This is not dif(cid:2)cult once the function has been +written using pattern matching, as above. + +(* eval : int -> char -> int -> char -> int -> int *) +fun eval x o1 y o2 z + += if o1 = "+" andalso o2 = "+" + +then (x + y) + z +else if o1 = "+" andalso o2 = "*" +then x + (y * z) +else if o1 = "*" andalso o2 = "+" +then (x * y) + z +else if o1 = "*" andalso o2 = "*" + +then (x * y) * z : int +else raise Match ; + +The last statement else raise Match ; makes explicit what happens if eval +is applied to a pair of operators other than "+" and "*". The speci(cid:2)cation of +eval, and the pattern matching of eval should have handled this case explicitly. +The latter actually does handle the error situation by raising the exception Match, +but it does so implicitly. We have left this problem to be solved until this late stage +to show that now we are actually forced to think about this missing part of the +speci(cid:2)cation: simply omitting the statement else raise Match ; will give a +syntax error. The problem speci(cid:2)cation only partially speci(cid:2)es the solution. The + +Revision: 6.47 + +(cid:8) +(cid:2) +(cid:5) +(cid:0) +(cid:1) +(cid:8) +(cid:2) +(cid:2) +(cid:8) +(cid:2) +(cid:5) +(cid:8) +(cid:2) +(cid:5) +(cid:0) +(cid:8) +(cid:2) +(cid:1) +(cid:2) +(cid:5) +(cid:5) +(cid:8) +(cid:8) +(cid:2) +(cid:5) +(cid:0) +(cid:1) +(cid:8) +(cid:5) +(cid:2) +(cid:8) +(cid:2) +(cid:5) +(cid:8) +(cid:2) +(cid:5) +(cid:0) +(cid:1) +(cid:8) +(cid:5) +(cid:2) +(cid:8) +(cid:5) +(cid:5) + 2.3. Characters,patternmatching,partialfunctions + +23 + +function eval is a partial function, a function which is unde(cid:2)ned for some values +of its arguments. + +The version of eval that uses the conditionals can be transformed into a C +program using a schema in the same way as the function euclid was translated +using a schema. However, we need a new schema, since the eval function con- +tains a cascade of conditionals, whereas the function schema of Section 2.2 sup- +ports only a single conditional. The development of this schema is the subject of +Exercise 2.2 below. For now, we will just give the C version of eval. + +In C, the type char is the type that encompasses all character values. Charac- +ter constants are written between single quotes. The code below is incomplete as +we are yet unable to deal with /*raise Match*/. We will postpone giving the +complete solution until Section 2.3.2, when we are satis(cid:2)ed with the structure of +eval. + +int eval( int x, char o1, int y, char o2, int z ) { + +if( o1 == (cid:146)+(cid:146) + +&& o2 == (cid:146)+(cid:146) + +) { + +return (x + y) + z ; + +} else { + +if( o1 == (cid:146)+(cid:146) + +&& o2 == (cid:146)*(cid:146) + +) { + +return x + (y * z) ; + +} else { + +if( o1 == (cid:146)*(cid:146) + +&& o2 == (cid:146)+(cid:146) + +) { + +return (x * y) + z ; + +} else { + +if( o1 == (cid:146)*(cid:146) + +&& o2 == (cid:146)*(cid:146) + +) { + +return (x * y) * z ; + +} else { + +/*raise Match*/ + +} + +} + +} + +} + +} + +The else-parts of the (cid:2)rst three if statements all contain only one statement, +which is again an if statement. This is a common structure when implementing +pattern matching. It becomes slightly unreadable with all the curly brackets and +the ever growing indentation, which is the reason why we drop the curly brackets +around these if statements and indent it (cid:3)atly: + +int eval( int x, char o1, int y, char o2, int z ) { + +if( o1 == (cid:146)+(cid:146) + +&& o2 == (cid:146)+(cid:146) + +) { + +return (x + y) + z ; + +} else if( o1 == (cid:146)+(cid:146) + +&& o2 == (cid:146)*(cid:146) + +) { + +return x + (y * z) ; + +} else if( o1 == (cid:146)*(cid:146) + +&& o2 == (cid:146)+(cid:146) + +) { + +return (x * y) + z ; + +} else if( o1 == (cid:146)*(cid:146) + +&& o2 == (cid:146)*(cid:146) + +) { + +Revision: 6.47 + + 24 + +Chapter2. Functionsandnumbers + +return (x * y) * z ; + +} else { + +/*raise Match*/ + +} + +} + +This indicates a chain of choices which are tried in order. The (cid:2)nal else-branch is +reached only if none of the previous conditions are true. + +Exercise 2.2 The function schema of Section 2.2 supports only a single conditional. +Generalise this schema to support a cascade of conditionals, as used by the +last SML and C versions of eval. + +Exercise 2.3 Give the table of correspondence for eval, using the function schema + +of Exercise 2.2. + +As discussed before, the else’s are redundant in this case because each branch +returns immediately. Reconciling this yields another equivalent program: +int eval( int x, char o1, int y, char o2, int z ) { + +if( o1 == (cid:146)+(cid:146) + +&& o2 == (cid:146)+(cid:146) + +) { + +return (x + y) + z ; + +} +if( o1 == (cid:146)+(cid:146) + +&& o2 == (cid:146)*(cid:146) + +) { + +return x + (y * z) ; + +} +if( o1 == (cid:146)*(cid:146) + +&& o2 == (cid:146)+(cid:146) + +) { + +return (x * y) + z ; + +} +if( o1 == (cid:146)*(cid:146) + +&& o2 == (cid:146)*(cid:146) + +) { + +return (x * y) * z ; + +} +/*raise Match*/ + +} + +During the execution of eval in the form above, the four if statements will be exe- +cuted one by one until one of the if statements matches. It is a matter of taste which +of the two forms, the else if constructions or the consecutive if statements, to +choose. The (cid:2)rst form is more elegant since it does not rely on the return state- +ment terminating the function. Therefore we will use that form. + +The chain of if statements is not ef(cid:2)cient. Suppose that o1 is a (cid:146)*(cid:146) +. The (cid:2)rst two if statements fail (because o1 is not a (cid:146)+(cid:146) + +, and o2 +is a (cid:146)+(cid:146) +). The third if +statement succeeds, so the value of (x * y) + z will be returned. There are two +tests on o1: it is compared with the character (cid:146)+(cid:146) +twice, whereas one test should +be suf(cid:2)cient. To remove this second test from the code, the program has to be +restructured. First, one has to test on the (cid:2)rst operator. If it is a (cid:146)+(cid:146) +, nested if +statements will be used to determine which of the two alternatives to evaluate. +Similarly, one if statement is needed to check if the (cid:2)rst operator is a (cid:146)*(cid:146) +. In this + +Revision: 6.47 + + 2.3. Characters,patternmatching,partialfunctions + +25 + +situation, nested if statements will determine which of the remaining two alterna- +tives to choose. This gives the following de(cid:2)nition of eval: + +int eval( int x, char o1, int y, char o2, int z ) { + +if( o1 == (cid:146)+(cid:146) + +) { + +if( o2 == (cid:146)+(cid:146) + +) { + +return (x + y) + z ; + +} else if( o2 == (cid:146)*(cid:146) + +) { + +return x + (y * z) ; + +} else { + +/*raise Match*/ + +} + +} else if( o1 == (cid:146)*(cid:146) + +) { + +if( o2 == (cid:146)+(cid:146) + +) { + +return (x * y) + z ; + +} else if( o2 == (cid:146)*(cid:146) + +) { + +return (x * y) * z ; + +} else { + +/*raise Match*/ + +} + +} else { + +/*raise Match*/ + +} + +} + +Exercise 2.4 Can you devise a translation schema between the pattern matching +SML code and the C code that uses a nested if-then-else? If not, what is the +problem? + +The above program has a functional equivalent, which is not as nice to read, even +though we have introduced two auxiliary functions xymul and xyadd to improve +the legibility: + +(* eval : int -> char -> int -> char -> int -> int *) +fun eval x o1 y o2 z += if o1 = "+" + +then xyadd x y o2 z +else if o1 = "*" + +then xymul x y o2 z : int +else raise Match + +(* xyadd : int -> int -> char -> int -> int *) +and xyadd x y o2 z + += if o2 = "+" + +then x + y + z +else if o2 = "*" + +then x + y * z : int + +Revision: 6.47 + + 26 + +Chapter2. Functionsandnumbers + +else raise Match + +(* xymul : int -> int -> char -> int -> int *) +and xymul x y o2 z + += if o2 = "+" + +then x * y + z +else if o2 = "*" + +then x * y * z : int +else raise Match ; + +It should be the task of the compiler to replace pattern matching with a suitable +if-structure. As C does not support pattern matching, it is the task of the C pro- +grammer to design an ef(cid:2)cient statement structure in the (cid:2)rst place. + +2.3.2 Partial functions + +Functions that use pattern matching or guards are often partially de(cid:2)ned. This +means that the function is not de(cid:2)ned for the entire domain: there are arguments +for which the function is unde(cid:2)ned. We have seen that the pattern matching ver- +sion of eval is only de(cid:2)ned if the operators are in the set (cid:23) +* . An attempt +to call the SML function eval 6 "/" 3 "+" 4 in its pattern matching version +will result in a run time error. The program is aborted because none of the de(cid:2)ni- +tions of eval match the call. + +(cid:146)+(cid:146) + +(cid:146)*(cid:146) + +If we were to leave the as yet un(cid:2)nished statement else /*raise Match*/ +out of our C versions of eval, a call to eval( 6, (cid:146)/(cid:146), +4 ) in the C +implementation will result in an unde(cid:2)ned value. Since none of the if statements +match, the end of the function is reached without executing a return statement. +Then the function will return with some arbitrary, unknown return value. Contin- +uing the computation with this unknown value makes little sense, it is therefore +good practice to prevent this from happening. The solution is to call the function +abort(), which is available from stdlib.h: + +3, (cid:146)+(cid:146), + +/*previous statements*/ +if( o2 == (cid:146)*(cid:146) + +) { + +return (x * y) * z ; + +} else { + +abort() ; + +} + +} else { + +abort() ; + +} + +A call to abort() causes a C program to stop execution immediately, to report a +run time error, and often to invoke a debugger or leave a memory dump. Then the +programmer can inspect which cases were missed out. The environment will often +allow the programmer to detect where the program failed, but it is good practice +to call printf just before aborting: + +printf("Arghh, first argument of (cid:146)eval(cid:146) + +is neither") ; + +Revision: 6.47 + +(cid:14) + 2.3. Characters,patternmatching,partialfunctions + +27 + +printf("a (cid:146)+(cid:146) +abort() ; + +nor an (cid:146)*(cid:146); + +it is (cid:146)%c(cid:146)\n", + +o1 ) ; + +A companion of abort is the function exit. A call to the function exit will ter- +minate the program. In contrast with abort, the function exit stops the program +gracefully: abort is called to signal a programming error (for example a missing +case), exit is called to signal a user error, or just to stop the program. The func- +tion exit has an integer parameter. The value 0, indicates that the program ran +successfully, any other value means that something went wrong. This number has +the same role as the number passed as the return value of main upon normal pro- +gram termination. + +2.3.3 Differences and similarities between characters and inte- + +gers + +Character constants are denoted between single quotes: the constants (cid:146)*(cid:146) +and +(cid:146)+(cid:146) +have already been shown before. Most single characters can be denoted in +this way, but for some characters a backslash escape is needed, like in SML. For ex- +ample, to denote a single quote, one has to write (cid:146)\(cid:146) +. The most important back- +slash escapes are: + +Bell signal (alarm) +Backspace (one character to the left) +Form feed (new sheet of paper or clear screen) +Newline +Carriage return (start again on the same line) +Tabulation (goes to next tab stop) +Vertical Tabulation (goes to next vertical tab) +A backslash (\ ) +A single quote (cid:147)(cid:146) (cid:148) +A double quote (cid:147)"(cid:148) +NULL-character (value 0) + +\a +\b +\f +\n +\r +\t +\v +\\ +\(cid:146) +\" +\0 +\ddd ddd should be a three digit octal number +\xdd dd should be a two digit hexadecimal number + +Although the type char is a separate type, it is actually part of the family of +integers. In C, characters are encoded by their integer equivalent. This means that +the character (cid:146)q(cid:146) +and the integer value 113 are actually identical (assuming that an +ASCII encoding of characters is used). Denoting an argument to be of type char +means that it is a small integer constant. The type char covers all integers that are +necessary to encode the character set. + +The fact that the characters are a subset of the integers has a number of con- +sequences. Firstly, functions that convert characters into integers and vice versa, +such as the chr and ord of SML and other languages, are unnecessary. Secondly, +all integer operators are applicable to characters. This can be useful as shown by + +Revision: 6.47 + +(cid:146) + 28 + +Chapter2. Functionsandnumbers + +the following equalities, which are all true: + +(cid:146)a(cid:146) +(cid:146)z(cid:146) +(cid:146)9(cid:146) + ++ 1 +- (cid:146)a(cid:146) +- (cid:146)0(cid:146) + +== (cid:146)b(cid:146), +== 25, +== 9 + +However, the following (in)equalities are also true: + +(cid:146)4(cid:146) +(cid:146)4(cid:146) + ++ (cid:146)5(cid:146) ++ (cid:146)5(cid:146) + +== (cid:146)i(cid:146), +!= (cid:146)9(cid:146) + +Care should be taken when using the equivalence between characters and integers +in C. + +To print a character, the function printf supports the %c-format. As an exam- + +ple, the following statement will print the letter q on the output: +) ; + +printf( "%c\n", (cid:146)q(cid:146) + +No assumptions can be made about the sign of character values. Characters are +stored in small integers, but it is up to the system to decide whether signed or un- +signed integers are used. This can have consequences as the comparison of two +characters c>d may be different from test c-d>0 (as when using unsigned charac- +ter arithmetic the latter is only false if c equals d). More about characters, particu- +larly how to read characters from the input, is discussed in Chapter 7. + +Exercise 2.5 Given that a machine encodes the character (cid:146)q(cid:146) with 113 and the + +character (cid:146)0(cid:146) with 48, what will the output of the following program be? + +int main( void ) { + +; +char c0 = (cid:146)0(cid:146) +int i0 = (cid:146)0(cid:146) +; +char cq = 113 ; +int iq = 113 ; +printf("(cid:146)%c(cid:146) +return 0 ; + += %d, (cid:146)%c(cid:146) + +} + += %d\n", c0, i0, cq, iq ) ; + +To be able to work with different character sets ef(cid:2)ciently, C supports a number +of standard predicates to classify characters. For example, the predicate isdigit +can be used to determine whether a character is a digit (cid:146)0(cid:146) +. The +most important of these predicates are: + +, . . . + +, (cid:146)1(cid:146) + +(cid:146)9(cid:146) + +isdigit(c) Yields true if c is a digit +isalpha(c) Yields true if c is a letter +isupper(c) Yields true if c is an uppercase letter +islower(c) Yields true if c is a lowercase letter +isspace(c) Yields true if c is whitespace (newline, tabulation, space) +isprint(c) Yields true if c is a printable character + +Additionally, two standard functions toupper and tolower are provided that +map a lower case letter to the upper case equivalent, and an upper case letter to + +Revision: 6.47 + + 2.4. Realnumbers + +29 + +the lower case equivalent respectively. To use any of these functions, one must +include the (cid:2)le ctype.h using the include directive: + +#include + +The ins and outs of the include statement are reserved for Chapter 8. An example +of the use of these functions is a function that converts a lowercase character to +an uppercase letter, and an uppercase character to a lowercase. Here is the SML +version: + +(* makeupper : char -> char *) +fun makeupper c + += if "a" <= c andalso c <= "z" + +then chr (ord c - ord "a" + ord "A") +else if "A" <= c andalso c <= "Z" + +then chr (ord c - ord "A" + ord "a") +else c ; + +Note that the implementation assumes that both the upper and lower case letters +are ordered contiguously. The C version replaces the tests on the characters with +some of the standard predicates, but the structure of the function is the same as in +SML: + +char makeupper( char c ) { + +if( islower( c ) ) { + +return toupper( c ) ; + +} else if( isupper( c ) ) { + +return tolower( c ) ; + +} else { + +return c ; + +} + +} + +2.4 Real numbers + +Characters and integers are suf(cid:2)cient to solve problems of a symbolic nature. For +solving numerical problems, it is often desirable to use real numbers. To explain +the use of real numbers in C, an algorithm that calculates (cid:0)(cid:2)(cid:1) +is discussed. In this +example, (cid:0) can be any real number, but (cid:12) must be a non-negative integer. The +speci(cid:2)cation of the power operator is as follows: + +(cid:1)(cid:3)(cid:2) + +(cid:5)(cid:7)(cid:2) + +(cid:4)(cid:9)(cid:8)(cid:11)(cid:10) + +(cid:3)(cid:5)(cid:4) + +(cid:8)(cid:5)(cid:9) + +(2.3) + +, except that it performs multiplications instead of addi- +The operator (cid:10) +tions. The ‘Indian’ algorithm to calculate this product is based on the following + +is like (cid:11) + +Revision: 6.47 + +(cid:0) +(cid:6) +(cid:2) +(cid:6) +(cid:0) +(cid:1) +(cid:0) +(cid:1) +(cid:7) +(cid:2) +(cid:0) + 30 + +Chapter2. Functionsandnumbers + +observation. Expanding the product above results in the following equation: + +(cid:1)(cid:3)(cid:2) + +(cid:1)(cid:22)(cid:5) + +(cid:4)(cid:3)(cid:0) + +(cid:4)(cid:5)(cid:0) + +(cid:1) div (cid:0) + +(cid:1) div (cid:0) + +There are (cid:12) multiplications which are grouped into two groups of (cid:12) div (cid:6) multipli- +cations, and, if (cid:12) +is odd, one single multiplication. This group of (cid:12) div (cid:6) multipli- +(cid:1) div (cid:0) , which gives the following recursive de(cid:2)nition +cations yields by de(cid:2)nition (cid:0) +of the power operator: + +(cid:11)(cid:10) + +sqr + +(cid:1) div (cid:0) + +where sqr + +&% + +if (cid:12) +if (cid:12) +is odd +otherwise + +(2.4) + +This reads as follows: any number to the power 0 equals 1; any number to the +power an-odd-number is equal to the number times the number to the power the- +odd-number-minus-1; and any number to the power an-even-number equals the +square of the number to the power the-even-number-divided-by-2. + +Exercise 2.6 The original de(cid:2)nition of (cid:0) + +(cid:13)(cid:12) + +(2.3) would require 127 multiplications +. How many multiplications are necessary using the second + +to calculate (cid:0) +de(cid:2)nition (2.4)? + +Exercise (cid:0) 2.7 Prove by induction on (cid:12) + +that the two de(cid:2)nitions of power, (2.4) and + +(2.3), are equivalent. + +Equation (2.4), de(cid:2)ning power and its auxiliary functions square and odd, +would be formulated in SML using conditionals as shown below: + +(* square : real -> real *) +fun square x : real = x * x ; + +(* odd : int -> bool *) +fun odd x = x mod 2 = 1 ; + +(* power : real -> int -> real *) +fun power r p + += if p = 0 + +then 1.0 (* Note, this is a real! *) +else if odd p + +then r * power r (p-1) +else square (power r (p div 2)) ; + +Revision: 6.47 + +(cid:0) +(cid:1) +(cid:0) +(cid:1) +(cid:0) +(cid:4) +(cid:0) +(cid:5) +(cid:0) +(cid:3) +(cid:3) +(cid:3) +(cid:0) +(cid:2) +(cid:1) +(cid:5) +(cid:0) +(cid:5) +(cid:0) +(cid:3) +(cid:3) +(cid:3) +(cid:0) +(cid:2) +(cid:1) +(cid:0) +(cid:8) +(cid:0) +(cid:0) +(cid:2) +(cid:6) +(cid:12) +(cid:0) +(cid:2) +(cid:4) +(cid:0) +(cid:1) +(cid:0) +(cid:6) +(cid:7) +(cid:8) +(cid:7) +(cid:9) +(cid:0) +(cid:14) +(cid:0) +(cid:0) +(cid:5) +(cid:0) +(cid:1) +(cid:2) +(cid:14) +(cid:1) +(cid:0) +(cid:8) +(cid:14) +(cid:1) +(cid:8) +(cid:8) +(cid:0) +(cid:8) +(cid:5) +(cid:8) +(cid:1) +(cid:2) +(cid:0) + 2.4. Realnumbers + +31 + +The following table gives the answers when applying the function power to a +sample set of arguments: + +power 3.0 +power 5.0 +power 1.037155 19 = + +0 = +1.0 ; +4 = 625.0 ; + +1.99999 ; + +The C equivalents of these functions and three example computations are shown +below as a complete C program. The general function schema of Exercise 2.2 has +been used to transform the SML functions into C. + +#include + +typedef enum { false=0, true=1 } bool ; + +double square( double x ) { + +return x * x ; + +} + +bool odd( int x ) { + +return x % 2 == 1 ; + +} + +double power( double r, int p ) { + +if( p == 0 ) { +return 1.0 ; + +} else if( odd( p ) ) { + +return r * power( r, p-1 ) ; + +} else { + +return square( power( r, p/2 ) ) ; + +} + +} + +int main( void ) { + +printf( "%f\n", power( 3, 0 ) ) ; +printf( "%f\n", power( 5, 4 ) ) ; +printf( "%f\n", power( 1.037155, 19 ) ) ; +return 0 ; + +} + +The power program contains 4 functions: square, odd, power and main. The +type bool has been declared, as in Section 2.2.6, so that the function odd is typed +properly. + +The function square results in a value of type double, which is an abbrevi- +ation for a double precision (cid:3)oating point number. Floating point numbers can +store fractional numbers and, in general, a wider range of numbers than integers. +The normal arithmetic operations, +, -, *, and /, can be performed on doubles. +The ins and outs of (cid:3)oating point numbers are discussed later in this chapter. To +print a (cid:3)oating point number, the function printf must be informed that it must + +Revision: 6.47 + + 32 + +Chapter2. Functionsandnumbers + +print a (cid:3)oating point style number. To accomplish this, the format %f must occur +in the format string. The function printf does not check whether the types in the +format string correspond with the types of the arguments. If printf is asked to +print something as a (cid:3)oating point number (with a %f format) but is supplied an +integer argument, then the program will print in the best case an arbitrary number +and in the worst case will crash. + +The execution of the power program is similar to the execution of the previous +programs. It starts in main, which in turn calls power, before calling printf to +print the (cid:2)rst result. + +Exercise 2.8 How many times are the functions square and power called when + +executing the third statement of main? + +2.4.1 Coercions of integers and (cid:3)oating point numbers + +Constants of the type double are denoted in scienti(cid:2)c notation with a decimal +point and an e preceding the exponent. For example 3.14159 is the value of (cid:0) +to +6 digits. The speed of light in metres per second is 2.9979e8. Floating point and +integer constants are distinguished by the presence of the decimal point and/or +exponent. The constant 12 denotes the integer twelve, but 12.0, 12e0 and 1.2e1 +denote the (cid:3)oating point number twelve. + +In C, doubles and integers are converted silently into each other when appro- +priate. This is called coercion. The arithmetic operators are overloaded: applied to +two doubles, these operators deliver a double; applied to two integers, the result +is an integer; and applied to one integer and one double, the integer is coerced to +a double, and the result is also a double. Although this comes in handy in many +cases (the constant 2 of type int is coerced into the constant 2.0 of type double +whenever that is necessary), it can lead to unexpected surprises. Here are a num- +ber of typical examples: +1.0 + 5.0/2.0 + +In both C and SML, the value of this expression will be 3.5. In C, the type of the +expression is double; in SML it is real. The same expression with an integer 5 +instead of the real 5.0 is: + +1.0 + 5/2.0 + +When interpreted as a C expression, the result will be the double 3.5. In this +case, because one of the operands of the division, 2.0, is a double, the other +operand is coerced to a double. This means that a (cid:3)oating point division and not +an integer division is required. Thus the overloading of the division operator is re- +solved towards a (cid:3)oating point division. The result of the division, 2.5, is added +to 1.0 to yield the double 3.5 as the total result of the expression. SML does not +accept this expression, since in SML the division operator / works exclusively on +reals. The SML system will complain about a type con(cid:3)ict between the operands +2.0 and 5 and the operator /. + +1.0 + 5/2 + +Revision: 6.47 + + 2.4. Realnumbers + +33 + +When interpreted as a C expression, the result will be the double 3.0. The di- +vision operator is applied to two integers, hence the result of the division is the +integer 2. Since one of the operands of the addition is a double, 1.0, the integer 2 +will be coerced into the double 2.0 so that the result of the expression as a whole +will be the double 3.0. When interpreted as an SML expression, the same type +error arises as in the previous case. + +1 + 5/2 + +As before, the operator / applied to two integers will be interpreted in C as integer +division. Thus, the result of the integer division is the integer 2. The operands of +the addition will both be integers, so that the value of the expression as a whole +will be the integer 3. When interpreted as an SML expression, the same type error +arises as in the previous two cases, this time it can be resolved by using a div +operator. + +. For example, the number % + +Internally, (cid:3)oating point numbers are stored in two parts: the fraction (or man- +tissa) and the exponent. If these are +and (cid:0) , the value of a (cid:3)oating point number +is given as +(cid:9) and +exponent (cid:0) +(cid:0) . Only a limited number of bits are available to store the exponent +and the mantissa. Let us consider, as an example, the layout of a (cid:3)oating point +number in a word of only 8 bits. We have opted for a three bit exponent and a (cid:2)ve +bit mantissa. This arrangement is schematical (the real representation is different, +consult a book on computer architecture for full details): + +is stored as mantissa % + +exponent + +(cid:4)(cid:3) + +mantissa + +(cid:6)(cid:5) + +The bits are numbered such that the least signi(cid:2)cant bit is the rightmost bit of each +of the mantissa and the exponent. + +tern for (cid:0) + +(cid:6)(cid:3) + +We assume that the exponent stores two’s-complement numbers. The bit pat- +is thus (cid:0)(cid:3)(cid:0)(cid:5)(cid:0) . The mantissa is arranged such that the most signi(cid:2)cant bit +counts the quarter, and so on. Therefore, the +(cid:9) as an 8-bit (cid:3)oating point + +counts the halves, the next bit + +% . The representation of % + +(cid:7)(cid:5) + +bit pattern for % +number is thus as shown below: + +is (cid:0)(cid:5)(cid:0) + +exponent + +mantissa + +(cid:9)(cid:8) + +, and the mantissa has around 15 dig- +Typically, the exponent has a range of (cid:0) +its precision. A consequence of the limited precision of the mantissa is that the +(cid:3)oating point numbers are a subset of the real numbers. Hence, two (cid:3)oating point +numbers can be found in C, say x and y, such that x does not equal y, and there +does not exist a (cid:3)oating point number between these two numbers. As an exam- +ple, in one C implementation there is no (cid:3)oating point number between: + +1.000000000000000222044604925031 + +and: + +1.000000000000000444089209850062 + +Revision: 6.47 + +(cid:12) +(cid:12) +(cid:5) +(cid:6) +(cid:1) +(cid:16) +(cid:2) +(cid:6) +(cid:9) +(cid:16) +(cid:6) +(cid:0) +(cid:0) +(cid:0) +(cid:2) +(cid:0) +(cid:1) +(cid:12) +(cid:12) +(cid:12) +(cid:0) +(cid:12) +(cid:2) +(cid:12) +(cid:1) +(cid:0) +(cid:12) +(cid:12) +(cid:16) +(cid:6) +(cid:9) +% +% +(cid:16) +(cid:2) +(cid:6) +(cid:0) +(cid:0) +(cid:0) +(cid:0) +(cid:0) +% +% +% +% +(cid:5) +(cid:1) +(cid:1) + Chapter2. Functionsandnumbers + +34 + +or between: + +345678912.0000000596046447753906 + +and: + +345678912.0000001192092895507812 + +The (cid:3)oating point numbers actually step through the real numbers, albeit in small +steps. The actual step size depends on the machine and compiler. This stepping +behaviour has a number of consequences. Firstly, many numbers cannot be rep- +resented exactly. As an example, many computer systems cannot represent the +number 0.1 exactly. For example, the nearest numbers are: + +0.0999999999999999916733273153113 + +and: + +0.1000000000000000055511151231257 + +For this reason (cid:3)oating point numbers should be manipulated with care: 0.1*10 +is not necessarily equal to 1.0. On some systems, it is greater than 1; on others, +it is less than 1. An equality test on (cid:3)oating point numbers, for example a==0.1, +will probably not give the expected result either. + +2.5 Functions as arguments + +The functions discussed so far operate on basic values like integers, (cid:3)oating point +numbers, or characters. Functions can also have a function as an argument. Func- +tions with functions as arguments are called higher order functions (as opposed to +(cid:2)rst order functions that operate on basic values). Higher order functions are a +powerful tool to the functional programmer. They can also be used in C but re- +quire some extra effort on the part of the programmer. + +2.5.1 Sums + +A common operation in mathematics, statistics, and even in everyday life is the +summation of a progression of numbers. We learn at an early age that the sum of +an arithmetic progression is: + +(cid:1)(cid:13)(cid:15) + +(cid:0)(cid:7)(cid:2) + +(cid:16)(cid:18)(cid:16)(cid:18)(cid:16) + +(cid:8)(cid:5)(cid:9) + +(2.5) + +Another useful sum, which is not so well known, adds successive odd numbers. +This sum can be used to calculate the square of a number: + +(cid:5)/(cid:15) + +(cid:16)(cid:18)(cid:16)(cid:18)(cid:16) + +(2.6) + +It is interesting to look at the differences and similarities of these sums. The differ- +ences are that they may have other begin and end values than (cid:0) and +(although +), and that they may have +in our two examples both summations range from (cid:0) + +to + +Revision: 6.47 + +(cid:6) +(cid:2) +(cid:2) +(cid:2) +(cid:15) +(cid:0) +(cid:4) +(cid:0) +(cid:2) +(cid:0) +(cid:0) +(cid:15) +(cid:5) +(cid:2) +(cid:0) +(cid:8) +(cid:6) +(cid:0) +(cid:2) +(cid:2) +(cid:2) +(cid:9) +(cid:2) +(cid:1) +(cid:6) +(cid:0) +(cid:0) +(cid:8) +(cid:0) +(cid:4) +(cid:0) +(cid:8) +(cid:9) +(cid:2) +(cid:1) +(cid:6) +(cid:5) +(cid:0) +(cid:0) +(cid:0) +(cid:8) +(cid:0) +(cid:15) +(cid:0) +(cid:15) +(cid:15) + 2.5. Functionsasarguments + +35 + +different expressions with (cid:0) . The similarity is that the value of (cid:0) ranges over a +progression of numbers, thus producing a sequence of expressions, each of which +uses a different value of (cid:0) . The values of these expressions are added to produce +the end result. The commonality in these patterns of computation can be captured +in a higher order function. The differences in these patterns of computation are +captured in the arguments of the higher order function. We meet here an applica- +tion of the important principle of procedural abstraction: look for common aspects +of behaviour and capture them in a procedure or function, whilst allowing for (cid:3)ex- +ibility by using arguments. The sum function shown below should be regarded as +the SML equivalent of the mathematical operator (cid:11) + +: + +(* sum : int -> int -> (int -> real) -> real *) +fun sum i n f = if i > n + +then 0.0 +else f i + sum (i+1) n f ; + +The function sum takes as arguments a begin value (argument i) and an end value +(argument n). Both of these are integers. As its third argument, we supply a func- +tion f which takes an integer (from the progression) and produces a real value to +be summed. + +The sum of an arithmetic progression is computed by the SML function +terminal below. It uses sum to do the summation. The actual version of f is the +function int2real. It is a function that converts an integer into a real number, so +that the types of the function sum and its arguments are consistent. + +(* terminal : int -> real *) +fun terminal n = let + +fun int2real i = real i + +in + +sum 1 n int2real + +end ; + +To see that this function does indeed compute the sum of an arithmetic progres- +sion we could try it out with some sample values of n. A better way to gain un- +derstanding of the mechanisms involved is to expand the de(cid:2)nition of sum by sub- +stituting the function int2real for f. This yields: + +(* terminal : int -> real *) +fun terminal n += let + +fun int2real i = real i +fun sum(cid:146) i n = if i > n + +then 0.0 +else int2real i + sum(cid:146) (i+1) n + +in + +sum(cid:146) 1 n + +end ; + +As an example, we can now ‘manually’ evaluate terminal 3. This requires a +series of steps to calculate the answer 6, according to the computational model for + +Revision: 6.47 + + 36 + +SML: + +terminal 3 (cid:0) + +Chapter2. Functionsandnumbers + +sum(cid:146) 1 3 +int2real 1 + sum(cid:146) (1+1) 3 +1.0 + sum(cid:146) 2 3 +1.0 + ( int2real 2 + sum(cid:146) (2+1) 3 ) +1.0 + ( 2.0 + sum(cid:146) 3 3 ) +1.0 + ( 2.0 + ( int2real 3 + sum(cid:146) (3+1) 3 ) ) +1.0 + ( 2.0 + ( 3.0 + sum(cid:146) 4 3 ) ) +1.0 + ( 2.0 + ( 3.0 + 0.0 ) ) +6.0 + +After these preparations, we are now ready to translate our functions sum and +terminal into C. Here is the C version of the sum function: + +double sum( int i, int n, double (*f) ( int ) ) { + +if( i > n ) { + +return 0.0 ; + +} else { + +return f( i ) + sum( i+1, n, f ) ; + +} + +} + +The sum function uses the function f as its third argument with the following syn- +tax: + +double (*f)( int ) + +This means that the argument f is itself a function which will return a double +value and which requires an integer value as an argument. (Strictly speaking f is a +pointer to a function, for now the difference can be ignored; pointers are discussed +in Chapter 4) The argument f is used by sum as a function to calculate the value of +f( i ). The general syntax for declaring a functional argument of a function is: + +(cid:1)(cid:7)(cid:6) (* (cid:0) )( (cid:1) + +(cid:2) , ... (cid:1)(cid:7)(cid:4) ) + +Here (cid:1)(cid:5)(cid:6) gives the type of the return value, and (cid:1) +ments of the function. (In turn, each of (cid:1)(cid:21)(cid:2) +equivalent of the type of this higher order function is: + +(cid:16)(cid:18)(cid:16)(cid:18)(cid:16)(cid:7)(cid:1)(cid:7)(cid:4) are the types of the argu- +(cid:16)(cid:18)(cid:16)(cid:18)(cid:16)(cid:19)(cid:1)(cid:5)(cid:4) , can be a function type.) The SML + +( (cid:1) + +(cid:2) -> ... (cid:1) + +(cid:4) -> (cid:1) + +(cid:6) ) + +A type synonym can be de(cid:2)ned for function types using the typedef mechanism +of C. As an example, de(cid:2)ne: + +typedef double (*int_to_double_funcs)( int ) ; + +This represents a type with the name int_to_double_funcs which encom- +passes all functions that have an int as an argument and result in a double value. +This type synonym would have been declared in SML as: +type int_to_real_funcs = int -> real ; + +Revision: 6.47 + +(cid:0) +(cid:0) +(cid:0) +(cid:0) +(cid:0) +(cid:0) +(cid:0) +(cid:0) +(cid:2) +(cid:14) +(cid:14) + 2.5. Functionsasarguments + +37 + +Exercise 2.9 Give the table of correspondence for the transformation of the SML +version of sum into the C version. Use the function schema from the begin- +ning of this chapter. + +The transformation of terminal into C poses a slight problem. C does not al- +low to de(cid:2)ne local functions, like the function int2real. Instead, int2real has +to be de(cid:2)ned before terminal. It would have been better if the auxiliary func- +tion int2real could have been declared locally to terminal, as it is only used +within that function. Most other programming languages do permit this, Pascal or +Modula-2 for example. + +double int2real( int i ) { + +return (double) i ; + +/* return i would suffice */ + +} + +double terminal( int n ) { + +return sum( 1, n, int2real ) ; + +} + +To stay close to the SML version, the function int2real uses an explicit type +the expression (double)i coerces the expression i to the type double. +cast: +In general, (type) expr coerces expr to the speci(cid:2)ed type. As type casts are +highly undesirable in C (more on this in later chapters), it is better just to write +return i, and leave the coercions to the compiler. + +Exercise 2.10 Use Equation (2.6) to de(cid:2)ne an SML function square. Then trans- + +form this function into C. + +Exercise 2.11 The value of (cid:0) + +( (cid:0) + +(cid:9)(cid:5)(cid:2) ) can be approximated using the following + +formula: + +(cid:0)(cid:7)(cid:0) + +(cid:16)(cid:21)(cid:16)(cid:18)(cid:16) + +(2.7) + +Give an SML function nearly_pi which calculates an approximation to (cid:0) +using the sum of the (cid:2)rst 2*n terms of the propagation given by (2.7). Pass +n as the argument to nearly_pi. Transform your function into C. + +2.5.2 Products + +The functions used in the previous section were all de(cid:2)ned in terms of sums. Sim- +ilar functions can be given in terms of products. Here is the product function in +SML: + +(* product : int -> int -> (int -> real) -> real *) +fun product i n f = if i > n + +then 1.0 +else f i * product (i+1) n f ; + +Revision: 6.47 + +(cid:2) +(cid:16) +(cid:0) +(cid:1) +(cid:0) +(cid:0) +(cid:0) +(cid:2) +(cid:6) +(cid:0) +(cid:1) +(cid:0) +(cid:0) +(cid:2) +(cid:2) +(cid:0) +(cid:9) +(cid:0) +(cid:0) +(cid:6) +(cid:2) +(cid:0) +(cid:2) +(cid:0) + 38 + +Chapter2. Functionsandnumbers + +With this new function product, we can de(cid:2)ne the factorial function in the +same way as terminal was de(cid:2)ned using sum: + +(* factorial : int -> real *) +fun factorial n = let + +fun int2real i = real i + +in + +product 1 n int2real + +end ; + +Exercise 2.12 Give the C versions of the product and factorial functions + +above. + +Exercise 2.13 The value of (cid:0) ( (cid:0) + +(cid:6)(cid:8)(cid:0) + +(cid:0) ) can be approximated using the following + +formula ( (cid:1) is the factorial function): + +(cid:0)(cid:2)(cid:1) + +(cid:6)(cid:3)(cid:1) + +(cid:16)(cid:18)(cid:16)(cid:21)(cid:16) + +(2.8) + +Give an SML function nearly_e which calculates an approximation to (cid:0) +using the sum of the (cid:2)rst n terms of the propagation given by (2.8), where +n is the argument to nearly_e. Transform your function into C. + +The sum and product functions are actually similar. Besides having a different +name, The product function differs from the sum function in only two aspects: + +1. The product function multiplies expressions where sum adds expressions. + +2. The product function uses the unit element 1.0 of the multiplication where + +sum uses the unit element 0.0 of the addition. + +The sum and product functions are so similar that it seems a good idea to try +to generalise further. The common behaviour of sum and product is a repeti- +tive application of some function. This repeated behaviour requires a base value +(0.0 for sum and 1.0 for product) and a method of combining results (+ for sum +and * for product). The common behaviour can be captured in a rather heavily +parametrised SML function repeat: + +(* repeat : (cid:146)a -> ((cid:146)b -> (cid:146)a -> (cid:146)a) -> + +int -> int -> (int -> (cid:146)b) -> (cid:146)a *) + +fun repeat base combine i n f + += if i > n + +then base +else combine (f i) (repeat base combine (i+1) n f) ; + +Revision: 6.47 + +(cid:6) +(cid:16) +(cid:0) +(cid:6) +(cid:0) +(cid:0) +(cid:2) +(cid:6) +(cid:0) +(cid:0) +(cid:0) +(cid:2) +(cid:0) +(cid:2) +(cid:0) +(cid:2) +(cid:0) +(cid:2) +(cid:1) +(cid:2) + 2.5. Functionsasarguments + +39 + +The repeat function has two functional arguments, combine and f. The best +way to understand how it works is by giving an example using repeat. Let us +rede(cid:2)ne the function sum in terms of repeat: + +(* sum : int -> int -> (int -> real) -> real *) +fun sum i n f += let + +fun add x y = x + y + +in + +repeat 0.0 add i n f + +end ; + +A succinct way to characterise the way in which repeat has been specialised to +sum is by observing that the following functions are equivalent: + +sum = repeat 0.0 add + +We have omitted the arguments i, n, and f as they are the same on both sides. +With repeat, we have at our disposal a higher order function which captures the +repetitive behaviour of sum, product, and many more functions. The repeat +function derives its power from the wide range of functions and values that can +be supplied for its (cid:2)ve arguments. + +Exercise 2.14 Rede(cid:2)ne the SML function product in terms of repeat. + +Exercise 2.15 Transform repeat and the rede(cid:2)ned version of sum into C func- + +tions. + +Exercise 2.16 Instead of using addition or multiplication, we might consider di- +vision as a method of combining results from the repeated function. This +can be used to compute so-called continued fractions. The golden ratio, in +mathematics prosaically known as the number (cid:0) +), can be +computed as follows: + +( (cid:0) + +(cid:2)(cid:2)(cid:1)(cid:4)(cid:3) + +(cid:0)(cid:7)(cid:2) + +(cid:2)(cid:2)(cid:1)(cid:7)(cid:6) + +(cid:6)(cid:9)(cid:8)(cid:11)(cid:10) + +(2.9) + +Give an SML function nearly_phi using the function repeat to calculate +. You should use the (cid:2)rst n terms of the continued +an approximation to (cid:0) +fraction given by (2.9); make n an argument of nearly_phi. Transform +your function into C. + +2.5.3 An extended example of higher order functions: bisection + +An interesting algorithm that can be implemented with higher order functions +is the bisection method. Bisection is the process of reducing a larger problem to +a smaller problem until the problem is so small that the solution is trivial (it is +an example of the important class of divide and conquer algorithms). The bisec- +tion method can be applied to search for some particular information in a mass + +Revision: 6.47 + +(cid:5) +(cid:0) +(cid:0) +(cid:0) +(cid:16) +(cid:4) +(cid:0) +(cid:0) +% +(cid:2) +(cid:0) +(cid:0) +(cid:2) +(cid:6) +(cid:0) +(cid:0) +(cid:0) +(cid:0) +(cid:2) +(cid:2) +(cid:10) +(cid:10) + 40 + +Chapter2. Functionsandnumbers + +of data. In this example, we use bisection to (cid:2)nd the root of a function, the (cid:8) -value +for which the function value is % . + +( (cid:14) + +Before we present the details of the bisection method, let us have a look at its +. +graphical interpretation. The picture below shows the graph of a function (cid:0) +This function intersects the X-axis at a point between the lines marked (cid:0) +( (cid:0) for +low) and (cid:14) +for high). These two points form the boundaries of an interval of +the X-axis which contains the root. The interval is rather large so it is not a good +approximation to the root. The smaller we can make the interval, the better the +approximation to the root becomes. The bisection method calculates a series of +approximations, with each subsequent one being better than the previous. The +process is stopped when we are suf(cid:2)ciently close to the root. + +X-axis + +(cid:1) and (cid:14) + +(cid:1) and (cid:14) + +(for mid) exactly between (cid:0) + +, the right half of the original interval between (cid:0) + +When given two initial boundaries (cid:0) +new point +resides to the left or to the right of the point + +(cid:1) , the bisection method calculates a +(cid:1) . It then checks whether the root +. If the root resides to the left of +is abandoned, and the +. This new interval +, the left +and +(cid:1) . This interval is also half the size of the original interval. The process of halv- +ing the current interval continues until it is deemed small enough to serve as an +approximation to the root. Here is a graphical rendering of the halving process: + +process continues with a new interval between (cid:0) +is half the size of the original interval. If the root resides to the right of +half is abandoned, and the process continues with the interval between (cid:0)(cid:22)(cid:2) + +(cid:1) and (cid:14) + +(cid:1) and (cid:14) + +Revision: 6.47 + +(cid:1) +(cid:8) +(cid:8) +(cid:1) +(cid:1) +(cid:14) +(cid:1) +(cid:0) +(cid:1) +(cid:0) +(cid:1) +(cid:8) +(cid:8) +(cid:12) +(cid:12) +(cid:12) +(cid:1) +(cid:2) +(cid:0) +(cid:12) +(cid:12) +(cid:0) +(cid:12) +(cid:14) + 2.5. Functionsasarguments + +41 + +Interval 1 + +Interval 2 + +Interval 3 + +Int. 4 + +X-axis + +Summarising, when given some initial estimates (cid:0) +(cid:2)nds two points (cid:0) +section point. It takes max + +(cid:1) , the bisection method +(cid:1) and (cid:14) +, which are as near as possible to either side of the inter- + +steps to reach this result. + +(cid:4) and (cid:14)(cid:1)(cid:0) + +(cid:1)(cid:13)(cid:12)(cid:7)(cid:14)(cid:16)(cid:15)(cid:17)(cid:8) + +To state more accurately what ‘as near as possible’ actually means, we will have +to use some mathematical notation. For the bisection method to work properly +there must be two points given, (cid:0) and (cid:14) +is a con- +. If (cid:0) +. The bisection method +tinuous function, there must be a root of (cid:0) between (cid:0) and (cid:14) +tries to (cid:2)nd such a root by calculating the arithmetic mean of (cid:0) and (cid:14) as +. +Given a particular set of values (cid:0) + +, there are three possibilities: + +, such that (cid:0) + +(cid:1)(cid:4)(cid:3) + +(cid:1)1(cid:12)(cid:9)(cid:8) + +If (cid:0) +root). + +(cid:1)(cid:13)(cid:12)(cid:9)(cid:8) + +% , the root has been found (or at least we are close enough to the + +is positive, we need to move left and continue to use + +If (cid:0) +value of (cid:14) + +. + +as the new + +(cid:1)1(cid:12) + +If (cid:0) + +is a negative number, we continue to use + +as the new value of (cid:0) . + +The bisection method thus closes in on the root, either by moving (cid:0) up or by mov- +ing (cid:14) down. The method is careful not to move either of these values past the root. +In mathematical notation we write: + +(cid:1).(cid:2) + +(cid:5)(cid:7)(cid:2) + +(cid:8)(cid:11)(cid:10) + +bisection + +(cid:1)1(cid:12) + +bisection + +(cid:1)(cid:13)(cid:12)(cid:7)(cid:14) + +(cid:8)(cid:16)(cid:14) + +bisection +bisection + +(cid:14)(cid:16)(cid:12)(cid:9)(cid:8)(cid:16)(cid:14) + +where + +(cid:10)(cid:6)(cid:5) + +(cid:1)(cid:13)(cid:12)(cid:9)(cid:8) + +if +if +if (cid:0) +otherwise + +(cid:0)(cid:8)(cid:5) + +(2.10) + +To express that we are close enough to the root, the bisection method uses two +. We say that we are close enough to a root if either the function +margins, (cid:5) and +result is close to 0, +(cid:10)(cid:9)(cid:5) , or if the root is between two bounds that are close +enough, + +. Below, this is visualised: + +(cid:1)(cid:13)(cid:12)(cid:9)(cid:8) + +Revision: 6.47 + +(cid:14) +(cid:1) +(cid:0) +(cid:1) +(cid:14) +(cid:2) +(cid:14) +(cid:0) +(cid:0) +(cid:5) +(cid:0) +(cid:1) +(cid:8) +(cid:8) +(cid:1) +(cid:0) +(cid:8) +(cid:10) +% +(cid:10) +(cid:0) +(cid:1) +(cid:14) +(cid:8) +(cid:12) +(cid:0) +(cid:2) +(cid:0) +(cid:10) +(cid:12) +(cid:10) +(cid:14) +(cid:1) +(cid:0) +(cid:1) +(cid:12) +(cid:1) +(cid:8) +(cid:12) +(cid:0) +(cid:0) +(cid:2) +(cid:6) +(cid:10) +(cid:2) +(cid:6) +(cid:0) +(cid:6) +(cid:6) +(cid:2) +(cid:6) +(cid:1) +(cid:0) +(cid:14) +(cid:14) +(cid:8) +(cid:0) +(cid:6) +(cid:7) +(cid:7) +(cid:7) +(cid:8) +(cid:7) +(cid:7) +(cid:7) +(cid:9) +(cid:12) +(cid:14) +(cid:29) +(cid:0) +(cid:8) +(cid:29) +(cid:12) +(cid:14) +(cid:29) +(cid:14) +(cid:0) +(cid:0) +(cid:29) +(cid:10) +(cid:7) +(cid:14) +(cid:11) +(cid:1) +(cid:0) +(cid:12) +(cid:0) +(cid:0) +(cid:2) +(cid:14) +(cid:6) +(cid:7) +(cid:29) +(cid:0) +(cid:29) +(cid:29) +(cid:14) +(cid:0) +(cid:0) +(cid:29) +(cid:10) +(cid:7) + 42 + +Chapter2. Functionsandnumbers + +so that the root is calculated with suf(cid:2)cient precision. Note + +We can choose (cid:5) and +that there is a problem if they are both set to zero. Regardless of how close (cid:0) and (cid:14) +are, they will never actually meet. Each step brings them closer by halving the size +of the interval. Only in(cid:2)nitely many steps could bring them together. Secondly, as +was shown in the previous section, computers work with limited precision arith- +metic only. This might cause unexpected problems with the implementation of +(cid:3)oating point numbers. By accepting a certain error margin, both these problems +are avoided. + +The above version of the bisection method requires (cid:0) + +to be an increasing func- + +tion, (cid:0) + +; it does not work for decreasing functions. +The mathematics of (2.10) can be transformed directly into an SML function. +Here are the constants eps and delta which represent our choice for the values +of (cid:5) and +. Making one of them (or both) larger reduces the accuracy of the method +but also causes it to (cid:2)nd an approximation to the root faster. Conversely, making +the values smaller slows down the process but makes it more accurate. + +(* eps,delta : real *) +val eps = 0.001 ; +val delta = 0.0001 ; + +The function bisection below follows the structure of the mathematics. To al- +low for some (cid:3)exibility, we have given bisection three arguments. The (cid:2)rst ar- +gument is the function f, whose root we are looking for. The other two arguments +are the real bounds l and h that represent the current low and high bounds of the +interval in which the root should be found. + +(* bisection : (real->real) -> real -> real -> real *) +fun bisection f l h + += let + +in + +val m = (l + h) / 2.0 +val f_m = f m + +if absolute f_m < eps + +then m +else if absolute(h-l) < delta + +then m +else if f_m < 0.0 + +then bisection f m h +else bisection f l m + +Revision: 6.47 + +(cid:7) +(cid:5) +(cid:7) +(cid:1) +(cid:0) +(cid:8) +(cid:10) +% +(cid:10) +(cid:0) +(cid:1) +(cid:14) +(cid:8) +(cid:7) + 2.5. Functionsasarguments + +43 + +end ; + +The local declarations for m and f_m ensure that no calculation is performed more +than once. This makes the bisection function more ef(cid:2)cient than a literal trans- +lation of the mathematics. The function absolute is de(cid:2)ned as follows: + +(* absolute : real -> real *) +fun absolute x = if x >= 0.0 + +then x +else ˜x ; + +As an example of using the bisection function, let us calculate the root of the +parabola function below. + +(* parabola : real -> real *) +fun parabola x = x * x - 2.0 ; + +The following table gives the roots of the parabola function when calcu- +The chosen value of eps is 0.001, +lated with different +and the chosen value for delta is 0.0001. +these cases, +In each of +parabola l < 0 < parabola h. + +initial bounds. + +bisection parabola 1.0 +2.0 = 1.41406 ; +bisection parabola 0.0 200.0 = 1.41449 ; +1.5 = 1.41445 ; +bisection parabola 1.2 + +The three answers are all close to the real answer (cid:0) +(cid:16)(cid:18)(cid:16)(cid:18)(cid:16) . The answers +are not exactly the same because bisection computes an approximation to the +answer. + +(cid:9)(cid:5)(cid:4) + +A complete C program implementing and using the bisection method is given + +below: + +#include + +double absolute( double x ) { + +if( x >= 0 ) { +return x ; + +} else { + +return -x ; + +} + +} + +const double eps=0.001, delta=0.0001 ; + +double bisection( double (*f)( double ), + +double l, double h ) { + +const double m = (l + h ) / 2.0 ; +const double f_m = f( m ) ; +if( absolute(f_m) < eps ) { + +return m ; + +} else if( absolute(h-l) < delta ) { + +return m ; + +Revision: 6.47 + +(cid:6) +(cid:0) +(cid:0) +(cid:16) +(cid:1) +(cid:0) +(cid:1) +(cid:6) +(cid:0) +(cid:2) + 44 + +Chapter2. Functionsandnumbers + +} else if( f_m < 0.0 ) { + +return bisection( f, m, h ) ; + +} else { + +return bisection( f, l, m ) ; + +} + +} + +double parabola( double x ) { + +return x * x - 2.0 ; + +} + +int main( void ) { + +printf( "%f\n", bisection( parabola, 1.0, +2.0 ) ) ; +printf( "%f\n", bisection( parabola, 0.0, 200.0 ) ) ; +printf( "%f\n", bisection( parabola, 1.2, +1.5 ) ) ; +return 0 ; + +} + +The C program for the bisection method includes the declaration of the two dou- +bles eps and delta: + +const double eps=0.001, delta=0.0001 ; + +This statement declares two global constants, that is, constants which are available +to all functions declared in the current module. Note that two declarations, declar- +ing them both to have type double, may be placed on one line. Two local con- +stants are declared in the body of the function bisection: + +const double m = (l + h ) / 2.0 ; +const double f_m = f( m ) ; + +These local constants are only visible within the body of the function bisection. +As any de(cid:2)nition in C, every constant must be declared before the value can be +used. Since the de(cid:2)nition of f_m uses the value of m, the de(cid:2)nition of f_m must +come after the de(cid:2)nition of m, so that m can be used to calculate f_m. + +Exercise 2.17 Generalise the function schema of Exercise 2.2 to support an arbi- +trary number of local de(cid:2)nitions as well as a cascade of conditionals. + +Exercise 2.18 The output of the bisection program consists of three different ap- +proximations of the root. Trace the (cid:2)rst two calls to printf to see why the +approximations are different. + +Exercise 2.19 Reformulate (2.10) so that it works for functions with a negative gra- +dient. Develop a general bisection function that automatically chooses be- +tween the version that only works for a positive gradient and the version +that also works for a negative gradient. + +2.6 Summary + +The following C constructs were introduced: + +Revision: 6.47 + + 2.6. Summary + +45 + +Functions The general form of a C function declaration is: + +(cid:2)(cid:1)(cid:0) + +(cid:2) , ... (cid:1) + +(cid:0) ( (cid:1) +/*constant declarations*/ +/*statements*/ + +(cid:4) ) { + +(cid:4)(cid:2)(cid:0) + +} + +Each function contains declarations of local values, and a series of state- +ments. When the function is called, the local constants will (cid:2)rst be evalu- +ated (in the order in which they are written), whereupon the statements are +executed, in the order speci(cid:2)ed. + +Constant declarations A constant (cid:3) with type (cid:1) and value (cid:0) + +is declared as follows: + +const (cid:1)(cid:1)(cid:3) = (cid:0) ; + +Statements Three forms of statements were discussed, the return statement, the +if statement and the function-call statement. A return statement has the fol- +lowing form: + +return (cid:0) ; + +It will terminate the execution of the current function, and return the value +of the expression (cid:0) as the return value of the function. The type of the expres- +sion should match the result type of the function. An if statement comes in +two (cid:3)avours, one with two branches, and one with only a then-branch: + +if( (cid:12) ) { + +} else { + +} + +if( (cid:12) ) { + +} + +Depending on the value of the conditional expression (cid:12) +, the (cid:2)rst or the sec- +, will be executed. The third state- +ond (if present) series of statements, (cid:0) or (cid:1) +ment discussed here is the expression statement, which consists simply of an +expression followed by a semicolon. This statement will evaluate the expres- +sion and discard the result. This can be useful, as the expression can have a +side effect. For example, calling the function printf will cause output to be +printed. + +Printing output The function printf requires a string as its (cid:2)rst argument, print- +ing it while substituting %-abbreviations with the subsequent arguments as +follows: + +%d Expects an integer argument, prints it decimally +%f Expects a (cid:3)oating point argument, prints it decimally +%c Expects a character argument, prints it as a char +%% Prints a single percent sign. + +Revision: 6.47 + +(cid:1) +(cid:6) +(cid:0) +(cid:1) +(cid:0) + 46 + +Chapter2. Functionsandnumbers + +Expressions Expressions in C are like SML expressions, except that some of the +operators are slightly different, as listed in Sections 2.2.4 and 2.2.5. Expres- +sions are typed, but there are fewer types than usual: booleans and charac- +ters are represented by integers. + +Types The following table relates C types to their SML and mathematical equiva- + +lents: + +SML Mathematics +int + +(cid:0)(cid:2)(cid:1) + +C type +int +char +double real (cid:0) + +(cid:146)a(cid:146) + +(cid:146)b(cid:146) + +(cid:146)!(cid:146) + +(cid:16)(cid:21)(cid:16)(cid:18)(cid:16) + +(cid:146)@(cid:146) + +(cid:16)(cid:21)(cid:16)(cid:18)(cid:16) + +Extra care has to be used when using characters (which are actually integers, +page 27). Booleans are also represented by integers and must be de(cid:2)ned ex- +plicitly, as shown in Section 2.2.6. + +Naming types : A name can be associated with a type using the keyword + +typedef: + +typedef (cid:1) + +(cid:0) ; + +This will bind the identi(cid:2)er (cid:0) +function types, (cid:0) must appear in the middle of (cid:1) : + +to the type (cid:1) . For some types, most notably + +typedef (cid:1)(cid:5)(cid:6) (* (cid:0) )( (cid:1) + +(cid:2) , ... (cid:1)(cid:5)(cid:4) ) ; + +This de(cid:2)nes a function type with name (cid:0) identical to the SML type: + +type (cid:0) = (cid:1) + +(cid:2) -> ... (cid:1)(cid:5)(cid:4) -> (cid:1)(cid:5)(cid:6) ; + +Enumerated types The general form of an enumerated type is: +(cid:1) , (cid:0) + +typedef enum { (cid:0) + +(cid:5)(cid:2) ... } (cid:1) ; + +The enum de(cid:2)nes a type by explicitly enumerating all possible values: (cid:0) +(cid:16)(cid:18)(cid:16)(cid:21)(cid:16) . The typedef causes the enumeration type to be known as (cid:1) . + +(cid:1) , (cid:0) + +(cid:2) , + +Main Each C program must have a main function. The function with the name + +main is the function that is called when the program is executed. + +The most important programming principles that we have addressed in this chap- +ter are: + +If we can convince ourselves that a functional solution to a problem satis(cid:2)es +its speci(cid:2)cation, the systematic transformation of the functional solution into +a C implementation should then give a reasonable guarantee that the C so- +lution also satis(cid:2)es the speci(cid:2)cation. The guarantee is not watertight, as the +transformations are informal. + +Revision: 6.47 + +(cid:4) +(cid:0) +(cid:23) +(cid:14) +(cid:14) +(cid:14) +(cid:14) +* +(cid:2) +(cid:6) +(cid:1) + 2.7. Furtherexercises + +47 + +If possible a function should be pure. That is, the function result should +depend only on the value of its arguments. The systematic transformation +method introduced in this chapter guarantees that all C functions are indeed +pure. + +(cid:1) A function should be total, that is, it should cover all its cases. The SML com- +piler will usually detect if a function is partially de(cid:2)ned. +In C, a runtime +error might occur or the program might return a random result, if the func- +tion is incomplete. By (cid:2)rst writing a function in SML, we obtain appropri- +ate warnings from the compiler, and if all such warnings are taken to heart, +our C programs will not have this problem. The language C does not have +built-in support for pattern matching, but a chain of if statements can be +employed to simulate pattern matching. + +(cid:1) A function should capture a common, useful behaviour. Variations in its be- +haviour should be possible by supplying different argument values. Com- +mon variations should be created as separate functions using specialised ver- +sions of more general behaviours. + +(cid:1) Functions should be strongly typed. Since SML is a strongly typed language, +it forces us to write strongly typed functions. Our systematic approach to +transforming SML programs into C programs should carry over the typing +discipline from the SML code into the C code. The implementation of poly- +morphic functions is explained later, in Chapters 4 and 8. + +(cid:1) Computers do not always follow the rules of mathematics. We have shown a +number of cases where standard mathematical laws do not apply to the data +that is used in computers. The representation of reals in a computer is partic- +ularly troublesome. The programmer should be aware of the approximative +nature of data in programs. + +One vitally important issue that we have not addressed in this chapter is the ef(cid:2)- +ciency of the C implementations. This is the subject of the next chapters. + +2.7 Further exercises + +Exercise 2.20 Write a program that converts a temperature from Centigrade to +. Test it on 0, 28, 37 and 100 + +, and (cid:0) + +(cid:26)% o (cid:1) + +% o (cid:0) + +% o (cid:0) + +o (cid:1) + +Fahrenheit: +degrees Centigrade. + +Exercise 2.21 Some computers offer a ‘population count’ instruction to count the +number of bits in an integer that are set to 1; for example, the population +count of 7 is 3 and the population count of 8 is 1. +(a) Give a speci(cid:2)cation of the pop_count function. Assume that the +(cid:0) bits as follows + +is represented as a sequence of + +given word (cid:8) + +(cid:16)(cid:21)(cid:16)(cid:18)(cid:16) + +(cid:1) , where each of the (cid:1) + +(cid:23)(cid:26)% + +(cid:22)* . + +Revision: 6.47 + +(cid:1) +(cid:0) +(cid:2) +(cid:6) +(cid:0) +(cid:9) +(cid:15) +(cid:2) +(cid:1) +(cid:4) +(cid:1) +(cid:4) +(cid:10) +(cid:2) +(cid:1) +(cid:2) +(cid:1) +(cid:8) +(cid:27) +(cid:14) +(cid:0) + 48 + +Chapter2. Functionsandnumbers + +(b) Give an SML function to compute the population count of a word, + +where an integer is used to represent a word. + +(c) Use the function schema to transform the SML function into an equiv- + +alent C function. + +(d) Show, step by step, that the C code is the result of direct transformation + +from SML code. + +(e) Write a main function to go with your C population count function. +The main function should call pop_count with at least three interest- +ing words and print the results. + +Exercise 2.22 A nibble is a group of four adjacent bits. A checksum of a word can +be calculated by adding the nibbles of a word together. For example, the +checksum of 17 is 2 and the checksum of 18 is 3. + +(a) Give a speci(cid:2)cation of the checksum function. Assume that a given +(cid:0) nibbles as follows +(cid:8) has a value in the range + +is represented as a sequence of (cid:0) + +(cid:1) , where each of the nibbles + +word (cid:8) + +(cid:16)(cid:18)(cid:16)(cid:18)(cid:16) + +(cid:2)(cid:1) + +(cid:2)(cid:1) + +(cid:16)(cid:21)(cid:16)(cid:18)(cid:16) + +(cid:9) . + +(b) Give an SML function to compute the checksum of a word, where an + +integer is used to represent a word. Test your function. + +(c) Use the function schema to transform the SML function into an equiv- + +alent C function. + +(d) Show, step by step, that the C code is the result of a direct transforma- + +tion from the SML code. + +(e) Write a main function to go with your C checksum function. The main +function should call checksum with at least three interesting words +and print the results. + +Exercise 2.23 The + +-th Fibonacci number (cid:0) + +is de(cid:2)ned by the following recurrence + +relation: + +(cid:15)2(cid:14) + +if + +(2.11) + +Write an SML function fib to calculate the +-th Fibonacci number. Then, +give the corresponding C function and a main program to test the C version +of fib for at least three interesting values of + +. + +Exercise 2.24 The ‘nFib’ number is a slight variation on the Fibonacci number. It + +is de(cid:2)ned as follows: + +(cid:15)2(cid:14) + +if + +Revision: 6.47 + +(cid:2) +(cid:15) +(cid:15) +(cid:10) +(cid:2) +(cid:15) +(cid:2) +(cid:15) +(cid:15) +% +(cid:0) +(cid:15) +(cid:4) +(cid:0) +(cid:4) +(cid:0) +(cid:2) +(cid:4) +(cid:0) +(cid:1) +(cid:0) +% +(cid:0) +(cid:2) +(cid:0) +(cid:0) +(cid:0) +(cid:4) +(cid:0) +(cid:0) +(cid:4) +(cid:10) +(cid:2) +(cid:2) +(cid:0) +(cid:4) +(cid:10) +(cid:0) +(cid:14) +(cid:15) +(cid:12) +(cid:6) +(cid:15) +(cid:15) +(cid:0) +(cid:4) +(cid:0) +(cid:2) +(cid:4) +(cid:0) +(cid:1) +(cid:0) +(cid:0) +(cid:0) +(cid:2) +(cid:0) +(cid:0) +(cid:0) +(cid:4) +(cid:0) +(cid:0) +(cid:2) +(cid:0) +(cid:4) +(cid:10) +(cid:2) +(cid:2) +(cid:0) +(cid:4) +(cid:10) +(cid:0) +(cid:14) +(cid:15) +(cid:12) +(cid:6) + 2.7. Furtherexercises + +49 + +(a) What is the difference between the Fibonacci series and the nFib se- + +ries? + +(b) Write an SML function nfib to calculate the +(c) Give the C function that corresponds exactly to the SML version of + +-th nFib number. + +nfib. + +(d) Write a main function that calls nfib and prints its result. Test the C + +version of nfib for at least three interesting values of + +. + +(e) If you study the formula for (cid:0) + +(cid:4) above closely, you will note that the +is the same as the number of function calls made by your SML +(cid:4) . Measure how long it takes SML to +(cid:1) and calculate the number of function calls per second for + +value (cid:0) +or your C function to calculate (cid:0) +compute (cid:0) +SML. + +(f) Perform the same measurement with your C program. Which of the +two language implementations is faster? By how much? Document +every aspect of your (cid:2)ndings, so that someone else could repeat and +corroborate your (cid:2)ndings. + +Exercise 2.25 Write an SML function power_of_power to compute the + +-th term + +in the following series: + +(cid:0)(cid:5)(cid:1)(cid:5)(cid:2)(cid:3)(cid:4) + +(cid:1)(cid:3)(cid:2) + +(cid:0)(cid:5)(cid:1)(cid:3)(cid:2)(cid:5)(cid:4) + +(cid:12)(cid:6)(cid:14) + +(cid:1)(cid:5)(cid:2) + +(cid:1)(cid:3)(cid:2) + +(cid:1)(cid:0) + +(cid:1)(cid:0) + +(cid:2)(cid:10)(cid:9) + +(cid:0)(cid:3)(cid:2)(cid:5)(cid:4) + +(cid:0)(cid:7)(cid:6)(cid:8)(cid:2) + +(cid:16)(cid:18)(cid:16)(cid:18)(cid:16) + +thus counts the number of occurrences of + +The +in the term. Give the C +version of power_of_power and give a main program to test the C version +for at least three interesting values of + +and + +. + +Exercise 2.26 The Newton-Raphson method is an alternative to the bisection +. It works on the basis of the +is approximately + +method for (cid:2)nding the roots of a function (cid:0) +following observation: if there is a value (cid:8) +zero, then a better approximation of the root is (cid:8) + +(cid:1)(cid:23)(cid:2) de(cid:2)ned as: + +(cid:8) , so that (cid:0) + +(cid:0)(cid:12)(cid:11) + +(2.12) + +and a point (cid:8) + +. The working of the +is the derivative of (cid:0) +Here, the function (cid:0) +Newton-Raphson method is shown schematically below. Given the func- +. The point where the +tion (cid:0) +(cid:1) , draw the tangent of (cid:0) +tangent intersects the X-axis, (cid:8)(cid:24)(cid:2) , is closer to the root of the function; (cid:8)(cid:24)(cid:2) +is +therefore a better approximation of the root. The process is repeated using +and intersecting it with the X-axis gives +(cid:8)(cid:10)(cid:2) . Drawing the tangent of (cid:0) +(cid:0) , which is closer to the root of the function than (cid:8)(cid:15)(cid:2) . The process +the point (cid:8) +can be repeated until the function value becomes (almost) zero. + +Revision: 6.47 + +(cid:15) +(cid:15) +(cid:4) +(cid:5) +(cid:15) +(cid:4) +(cid:9) +(cid:1) +(cid:0) +(cid:14) +(cid:4) +(cid:9) +(cid:2) +(cid:4) +(cid:9) +(cid:0) +(cid:0) +(cid:4) +(cid:12) +(cid:0) +(cid:14) +(cid:4) +(cid:9) +(cid:5) +(cid:0) +(cid:4) +(cid:12) +(cid:14) +(cid:4) +(cid:9) +(cid:3) +(cid:0) +(cid:4) +(cid:12) +(cid:4) +(cid:15) +(cid:12) +(cid:12) +(cid:15) +(cid:1) +(cid:8) +(cid:8) +(cid:1) +(cid:8) +(cid:8) +(cid:8) +(cid:8) +(cid:8) +(cid:8) +(cid:1) +(cid:2) +(cid:0) +(cid:8) +(cid:8) +(cid:0) +(cid:0) +(cid:1) +(cid:8) +(cid:8) +(cid:8) +(cid:1) +(cid:8) +(cid:8) +(cid:8) +(cid:11) +(cid:1) +(cid:8) +(cid:8) +(cid:1) +(cid:8) +(cid:8) +(cid:1) +(cid:8) +(cid:8) +(cid:1) +(cid:8) +(cid:1) +(cid:8) +(cid:1) +(cid:8) +(cid:2) +(cid:8) + 50 + +Chapter2. Functionsandnumbers + +X-axis + +(cid:8)(cid:10)(cid:2) + +(a) Given the function (cid:0) + +, its derivative (cid:0) + +, and an initial approxima- + +tion (cid:8) + +(cid:1) , show the mathematics for calculating the root. + +(b) Give an SML function newton_raphson that + +implements the +Newton-Raphson method on the basis of the mathematics from (a) +above. Make sure that as much information as possible is captured by +arguments. + +(c) Use your Newton-Raphson function to calculate the root of the + +parabola function from Section 2.5. + +(d) Transform the SML functions from (b) and (c) above into C and form a +complete C program to calculate the roots of the parabola function. + +(e) Trace the evaluation of the following C expression: + +newton_raphson( parabola, parabola_, 0.001, 1.5 ) + +(f) The Newton Raphson method is a fast method to determine the root, +but it does not provide a root in all cases. As an example, if one tries +to (cid:2)nd the root of (cid:0) +(cid:0) , the root will be found if the initial +value for (cid:8) +. What happens if +(cid:9) , but not if the initial value is +the Newton-Raphson algorithm is used to determine the root of (cid:2) +(cid:0) , +starting with (cid:8) + +is % + +? + +Revision: 6.47 + +(cid:8) +(cid:1) +(cid:8) +(cid:0) +(cid:0) +(cid:1) +(cid:8) +(cid:8) +(cid:1) +(cid:8) +(cid:8) +(cid:11) +(cid:1) +(cid:8) +(cid:8) +(cid:1) +(cid:8) +(cid:8) +(cid:0) +(cid:2) +(cid:0) +(cid:0) +(cid:16) +(cid:2) +(cid:0) +(cid:0) +(cid:0) +(cid:2) + c(cid:0) + +1995,1996 Pieter Hartel & Henk Muller, all rights reserved. + +Chapter 3 + +Loops + +In the preceding chapter, we have used a purely functional programming style. +This style has the advantage that the correspondence between algorithms and C +implementations is close. However, it is not always possible to use this style of +programming in C for three reasons. Firstly, not all C data types are (cid:2)rst class cit- +izens; For example in C, a function cannot return an array as a result, whereas it +can return a structure as a result. Secondly, more ef(cid:2)cient implementations which +require the use of constructs not directly available in a functional language, such +as loops, are sometimes possible. A good C compiler would generate the same +ef(cid:2)cient code for loops and tail recursive functions. Using loops to implement +non-tail recursive functions makes it possible to achieve a degree of ef(cid:2)ciently be- +yond what most C compilers are able to offer using just recursion. Thirdly, the +ef(cid:2)ciency of the allocation and reuse of store can often be improved if we do not +adhere strictly to the functional style. + +This chapter presents a model of the store that will serve as the basis for writ- +ing idiomatic and ef(cid:2)cient C functions. The internal workings of these functions +may no longer be functional, but the interface to these functions will stay purely +functional. We also provide a number of techniques to assist in the development +of C functions from their functional counterparts. These techniques are based on +the use of program transformation schemas, similar to the function schema of the +previous chapter. The schemas of the present chapter are used to transform tail re- +cursive functions into loops. It is generally not possible to use a schema for trans- +forming non-tail recursion into tail recursion, because this requires intelligence +that cannot be captured in a schema. + +3.1 A model of the store + +Computers have a store in which data is entered, maintained, and retrieved. The +functional programming style hides the details of the storage management from +the programmer. This makes life easy. All the programmer needs to consider is +the algorithmic aspects of problem solving. The disadvantage of hiding the ma- +nipulation of the store is that the programmer sometimes may wish to exert con- +trol over exactly how data is manipulated in order to improve the ef(cid:2)ciency of + +51 + + 52 + +Chapter3. Loops + +an implementation. In general, this extra control is not available to functional pro- +grammers. It is the domain of the imperative programmer. Thus in a sense, imper- +ative programming is a relatively low level activity. This does not imply that an +imperative programmer cannot build programs that achieve both a high level of +abstraction and an ef(cid:2)cient implementation. However, to achieve these two aims, +the imperative programmer needs to do quite a lot of work. + +The store of a computer may be implemented in many ways. The main mem- +ory, the caches, the registers, as well as secondary memory (disks), and even +backup storage all implement parts of the store. It would be unreasonable for a +programmer to have to think about all these different storage devices. It is eas- +ier to think in terms of a model of the store rather than the store itself. The model +captures the essential aspects of the store and abstracts away inessential details. + +A model of the store is a mapping of locations onto values. Locations are usually +positive natural numbers, but we abstract from that and give names to the cells. +The values are held in (cid:2)xed size cells; most computers today use 32-bit cells. Val- +ues can be arbitrary, provided they (cid:2)t into the available space. Here is a small store +with 4 cells, named (cid:147)A(cid:148), (cid:147)B(cid:148), (cid:147)C(cid:148) and (cid:147)D(cid:148): + +A: + +B: + +C: + +D: + +(cid:16)(cid:21)(cid:16)(cid:18)(cid:16) + +(cid:16)(cid:21)(cid:16)(cid:18)(cid:16) + +(cid:16)(cid:21)(cid:16)(cid:18)(cid:16) + +(cid:16)(cid:21)(cid:16)(cid:18)(cid:16) + +The store of the computer is accessed mainly through the arguments and the local +variables of the functions (we will discuss global variables in Chapter 8). Unless +essential, we will not differentiate between arguments and local variables, and we +will simply refer to both as the arguments, since the values that are carried by the +local variables must be stored somewhere, just like the arguments. It is the task of +the compiler to allocate cells for the arguments that occur in programs. + +The number of available cells is related to the amount of storage that is phys- +ically present in the computer. Therefore, a realistic model of the store will limit +the number of available cells. Storage and thus cells are often in short supply, and +using store impacts performance. The compiler will need to do its best to allocate +arguments to cells in such a way that cells are reused as often as possible. + +Consider instructing the computer directly, as is common with pocket calcula- +tors. Firstly, store four numbers, arbitrarily chosen as 17, 3, 1, and 1000, in the cells, +thus allocating one cell to each number: + +A: + +B: + +C: + +D: + +%(cid:26)% + +%(cid:26)% + +%(cid:26)% + +%(cid:26)% + +Revision: 6.41 + +(cid:0) +(cid:6) +% +(cid:2) +% +(cid:0) +(cid:0) +% + 3.2. Localvariabledeclarations andassignments + +53 + +To add all the numbers together, start by adding 17 and 3. Then add 1 to the result, +and so on. Where would the intermediate sums, 20 and 21, and the (cid:2)nal result +(1021) be stored? All cells are in use and there is no free cell. The solution is to +reuse cells after they have served their useful life. One possibility would be to use +cell (cid:147)A(cid:148) for this purpose: + +A: + +B: + +C: + +D: + +%(cid:26)% + +%(cid:26)% + +(cid:26)% + +%(cid:26)% + +%(cid:26)% + +%(cid:26)% + +%(cid:26)% + +%(cid:26)% + +%(cid:26)% + +%(cid:26)% + +%(cid:26)% + +%(cid:26)% + +%(cid:26)% + +%(cid:26)% + +%(cid:26)% + +%(cid:26)% + +stage 1 + +stage 2 + +stage 3 + +stage 4 + +The simple model of the store shown above is adequate for our purposes. It can be +re(cid:2)ned in several ways; the interested reader should consult a book on computer +architecture [14, 2]. Here, the simple model of the store will be used to investigate +the behaviour of a number of C functions. + +3.2 Local variable declarations and assignments + +To illustrate how the model of the store might help us to understand C programs +let us now write a function that implements the addition of the four cells. This pro- +gram needs two new concepts, one to access the store and one concept to modify +the store: + +(cid:1) Store access is provided by a local variable declaration, which associates a name +with a cell in the store. The declaration of a local variable has the following +general form: +(cid:8) = (cid:0) ; + +Here (cid:1) should be a type, (cid:8) should be an identi(cid:2)er and (cid:0) should be the initial +value of the cell associated with (cid:8) +. The value (cid:0) should have type (cid:1) . The local +variables can be declared immediately at the beginning of each block of code +(that is just after a {). The cell can be used in the scope of the variable, that is, +until the end of a block of code (until the matching closing curly bracket }). +A local variable declaration differs from a local constant declaration in that +the variable does not represent a (cid:2)xed value, but instead a cell where values +can be stored and updated. + +It is good programming practice to always initialise local variables, although +C does not require it. An uninitialised local variable declaration has the fol- +lowing general form: + +(cid:8) ; + +Revision: 6.41 + +(cid:0) +(cid:6) +% +(cid:2) +% +(cid:0) +(cid:0) +% +(cid:6) +% +(cid:2) +% +(cid:0) +(cid:0) +% +(cid:6) +(cid:0) +% +(cid:2) +% +(cid:0) +(cid:0) +% +(cid:0) +% +(cid:6) +(cid:0) +% +(cid:2) +% +(cid:0) +(cid:0) +% +(cid:1) +(cid:1) + 54 + +Chapter3. Loops + +Uninitialised variables in C have an arbitrary value. No assumptions should +thus be made about the value of an uninitialised variable. Errors caused by +the accidental omission of an initialisation are dif(cid:2)cult to (cid:2)nd, so it is a good +idea to check that variable declarations contain an initialisation when some- +thing strange happens to your program. + +(cid:1) An assignment statement can be used to change the value of the cell associ- +ated with a local variable. Assignment statements have the general form: + +(cid:8) = (cid:0) ; + +is an identi(cid:2)er and (cid:0) should be an expression of the same type as (cid:8) + +. +Here (cid:8) +An assignment statement may be written anywhere after the declarations of +a block. + +The function main below uses local variable declarations and assignments to im- +plement a C program that adds the contents of the four cells as described in the +previous section. The function main (cid:2)rst declares four appropriately initialised +local variables, A, B, C and D. It then uses three assignment statements to add the +values. The cell associated with the local variable A is used to store the intermedi- +ate and (cid:2)nal results. The program (cid:2)nally prints the sum as stored in A and returns +to the calling environment. +int main( void ) { + +17 ; +int A = +3 ; +int B = +int C = +1 ; +int D = 1000 ; +A = A + B ; +A = A + C ; +A = A + D ; +printf( "%d\n", A ) ; +return 0 ; + +} + +We will now investigate how we can use the model of the store to study the be- +haviour of a C program in detail. We do this by making an execution trace. An +execution trace is a step by step account of the execution of a program, showing +the values associated with the variables involved in the execution. + +Execution begins with a call to main. This is shown in Step 1 below. The cells +associated with A, B, C and D are also allocated at Step 1. The rendering of the +store is associated with the position in the program that has been reached by the +execution. We draw a box representing the store with an arrow pointing at the +position in the program that has been reached. + +Revision: 6.41 + + 3.2. Localvariabledeclarations andassignments + +55 + +int main( void ) { + +17 ; +int A = +3 ; +int B = +int C = +1 ; +int D = 1000 ; +A = A + B ; +A = A + C ; +A = A + D ; +printf( "%d\n", A ) ; +return 0 ; + +} + +A : 17 +B : 3 +C : 1 +D : 1000 + +(Step 1) + +At Step 2 the store is updated by the (cid:2)rst assignment because the value associated +with A changes from 17 to 20: +int main( void ) { + +17 ; +int A = +3 ; +int B = +int C = +1 ; +int D = 1000 ; +A = A + B ; +A = A + C ; +A = A + D ; +printf( "%d\n", A ) ; +return 0 ; + +} + +A : 20 +B : 3 +C : 1 +D : 1000 + +(Step 2) + +At Step 3 the store is updated again to re(cid:3)ect the effect of the second assignment +statement: + +int main( void ) { + +17 ; +int A = +3 ; +int B = +int C = +1 ; +int D = 1000 ; +A = A + B ; +A = A + C ; +A = A + D ; +printf( "%d\n", A ) ; +return 0 ; + +} + +A : 21 +B : 3 +C : 1 +D : 1000 + +(Step 3) + +The last assignment statement updates the store again to yield the (cid:2)nal association +of the value 1021 with the variable A: + +Revision: 6.41 + +(cid:0) +(cid:0) +(cid:0) + 56 + +Chapter3. Loops + +int main( void ) { + +17 ; +int A = +3 ; +int B = +int C = +1 ; +int D = 1000 ; +A = A + B ; +A = A + C ; +A = A + D ; +printf( "%d\n", A ) ; +return 0 ; + +} + +A : 1021 +B : 3 +C : 1 +D : 1000 + +(Step 4) + +The printf statement at Step 5 prints the value 1021 associated with A. The +printf statement does not alter the contents of the store, so we will not redraw +the box that displays the contents: + +int main( void ) { + +17 ; +int A = +3 ; +int B = +1 ; +int C = +int D = 1000 ; +A = A + B ; +A = A + C ; +A = A + D ; +printf( "%d\n", A ) ; +return 0 ; + +} + +(Step 5) + +The function main (cid:2)nally returns to its caller delivering the return value 0. The +entry return 0 in the store box below indicates that the return value needs to +be communicated from the callee (the function main) to the caller. The latter may +need this value for further computations. In this particular case the caller is the +operating system, which interprets a return value of 0 as successful execution of +the program, and any other value as an indication of a failure. + +Revision: 6.41 + +(cid:0) +(cid:0) + 3.3. Whileloops + +57 + +int main( void ) { + +17 ; +int A = +3 ; +int B = +int C = +1 ; +int D = 1000 ; +A = A + B ; +A = A + C ; +A = A + D ; +printf( "%d\n", A ) ; +return 0 ; + +} + +return 0 + +(Step 6) + +A cell can only be reused if the cell is not going to be accessed anymore. Therefore +the order of events is important. The programmer should be able to control that +order so as to guarantee the appropriate sequencing of events. In the case of the +example above, it would not be possible to start adding 1000 to 1 while still using +cell A for intermediate results. This would destroy the value 17 before it is used. +The reuse of cell A destroys the old value associated with that cell. + +One must be careful not to destroy a value that is needed later, as it will in- +troduce an error. One of the major differences between functional programming +and imperative programming is that functional programmers cannot make such +errors, for they have no direct control over store reuse. + +3.3 While loops + +Consider the problem of (cid:2)nding the next leap year. The next leap year following +any year (cid:2) after 1582 is given by the speci(cid:2)cation: + +leap (cid:0) + +leap + +(cid:0)(cid:2)(cid:1) + +(cid:4)(cid:6)(cid:29) + +(cid:18)! #" + +&% + +(cid:18)! #" + +&% + +(cid:18)! #" + +(3.1) + +The condition for a leap year is a bit too long for this example, so we simplify it +only to give the right answer between 1901 and 2099 (the general case is left to the +reader, see Exercises 3.2 and 3.4): + +leap (cid:0) + +leap + +(cid:4)-(cid:10) + +(cid:0)(cid:3)(cid:1) + +(cid:4)(cid:30)(cid:29) + +(cid:18)! #" + +)% + +(3.2) + +Given a particular year (cid:2) +moves onto the next year if the current year is not a leap year. + +, a leap year cannot be far away. The following algorithm + +(* leap : int -> int *) +fun leap y = if y mod 4 <> 0 + +then leap (y+1) +else y ; + +Revision: 6.41 + +(cid:0) +(cid:2) +(cid:4) +(cid:10) +(cid:2) +(cid:4) +(cid:1) +(cid:2) +(cid:8) +(cid:0) +(cid:18) +(cid:23) +(cid:0) +(cid:27) +(cid:2) +(cid:0) +(cid:12) +(cid:2) +’ +(cid:1) +(cid:0) +(cid:1) +(cid:0) +(cid:8) +’ +(cid:1) +(cid:1) +(cid:0) +(cid:0) +% +% +(cid:13) +(cid:0) +(cid:8) +(cid:1) +(cid:1) +(cid:0) +(cid:1) +% +% +(cid:0) +% +(cid:8) +(cid:8) +* +(cid:2) +(cid:2) +(cid:4) +(cid:1) +(cid:2) +(cid:8) +(cid:0) +(cid:18) +(cid:23) +(cid:0) +(cid:27) +(cid:2) +(cid:0) +(cid:12) +(cid:2) +’ +(cid:1) +(cid:0) +(cid:1) +(cid:0) +(cid:8) +* + 58 + +Chapter3. Loops + +Exercise (cid:0) 3.1 Prove that the function leap satis(cid:2)es (3.2). + +The technique that has been developed in the previous chapter to translate from +an SML function to a C function is directly applicable: + +int leap( int y ) { + +if( y % 4 != 0 ) { + +return leap( y+1 ) ; + +} else { + +return y ; + +} + +} + +Exercise 3.2 Modify the SML function leap to deal with any year after 1582 using + +(3.1) and transform the SML function into C. + +When this function is executed as part of a program, the function leap associates +a cell with the argument y. The cell is initialised and used, but it is not reused. To +see this, we will look at the execution trace of leap. Execution begins with a call +to leap with some suitable argument value, say 1998. This is Step 1 below. The +argument y is also allocated at Step 1. + +y : 1998 + +(Step 1) + +int leap( int y ) { + +if( y % 4 != 0 ) { + +return leap( y+1 ) ; + +} else { + +return y ; + +} + +} + +At Step 2 the test on y is performed, which yields true. This implies that a new call +must be made to leap. + +int leap( int y ) { + +if( y % 4 != 0 ) { + +return leap( y+1 ) ; + +} else { + +return y ; + +(Step 2) + +} + +} + +. This signals that, until the new call terminates, the cell referred to as y(cid:146) + +At Step 3 the function leap is entered recursively. The store is extended with the +cell necessary to hold the new argument. The old argument is kept for later use +as y(cid:146) +is inaccessible: there is no identi(cid:2)er in the program with this name, and it is not +even a legal identi(cid:2)er in C. The store is used as a stack of cells, with only the most +recently stacked cell being accessible. There are now 2 cells in use; the new cell +stacked on top of the old one: + +Revision: 6.41 + +(cid:0) +(cid:0) + 3.3. Whileloops + +59 + +y : 1999 +y(cid:146) + +: 1998 + +(Step 3) + +int leap( int y ) { + +if( y % 4 != 0 ) { + +return leap( y+1 ) ; + +} else { + +return y ; + +} + +} + +At Step 4 the test on the new value of y is performed, yielding true again. The +store remains unaltered, and it has therefore not been redrawn: + +int leap( int y ) { + +if( y % 4 != 0 ) { + +return leap( y+1 ) ; + +} else { + +return y ; + +(Step 4) + +} + +} + +At Step 5 the function leap is entered for the third time. This extends the store +with a third cell. The previous values of y are now shown as y(cid:146) and y(cid:146) +. Only y +is accessible. + +y : 2000 +y(cid:146) +y(cid:146) + +: 1999 + +: 1998 + +(Step 5) + +int leap( int y ) { + +if( y % 4 != 0 ) { + +return leap( y+1 ) ; + +} else { + +return y ; + +} + +} + +At Step 6 the test on the latest value of y is performed, yielding false, because 2000 +is divisible by 4. The store remains the same: + +int leap( int y ) { + +if( y % 4 != 0 ) { + +return leap( y+1 ) ; + +(Step 6) + +} else { + +return y ; + +} + +} + +At Step 7 the current call to leap reaches the else-branch of the conditional. The +store remains unaltered. + +Revision: 6.41 + +(cid:0) +(cid:0) +(cid:146) +(cid:0) +(cid:146) +(cid:0) + 60 + +Chapter3. Loops + +int leap( int y ) { + +if( y % 4 != 0 ) { + +return leap( y+1 ) ; + +} else { + +return y ; + +} + +} + +(Step 7) + +At Step 8 the third call to leap terminates, returning the value 2000 to the previ- +ous call. In returning, the cell allocated to the argument of the third call is freed. +There are now two cells in use, of which only y is accessible. + +int leap( int y ) { + +if( y % 4 != 0 ) { + +return leap( y+1 ) ; + +} else { + +return y ; + +} + +} + +return 2000 +y : 1999 +y(cid:146) + +: 1998 + +(Step 8) + +At Step 9 the second call also returns, removing its argument. + +int leap( int y ) { + +if( y % 4 != 0 ) { + +return leap( y+1 ) ; + +} else { + +return y ; + +} + +} + +return 2000 +y : 1998 + +(Step 9) + +At Step 10 the initial call to leap returns the desired result, 2000. This also frees +the last cell y in use by leap. +int leap( int y ) { + +if( y % 4 != 0 ) { + +return leap( y+1 ) ; + +} else { + +return y ; + +} + +} + +return 2000 + +(Step 10) + +The execution trace of leap(1998) shows how arguments are allocated and re- +membered during calls. The trace also shows the return values of the functions +involved in the trace. The trace of leap does not show that arguments always +have to be remembered. In fact, the leap function does not require arguments to +be remembered when the calls are made. The function leap is said to be tail re- +cursive: a function is tail recursive if the last expression to be evaluated is a call to +the function itself. To contrast tail recursive with non-tail recursive functions, here + +Revision: 6.41 + +(cid:0) +(cid:0) +(cid:0) +(cid:0) + 3.3. Whileloops + +61 + +is an SML example of the latter: +(* fac : int -> int *) +fun fac n = if n > 1 + +then n * fac (n-1) +else 1 ; + +The last expression to be evaluated in the function body is the multiplication and +not the call to fac itself. Before discussing non-tail recursive functions, a method +will be presented that gives an ef(cid:2)cient C implementation of a tail recursive func- +tions. + +3.3.1 Single argument tail recursion + +The execution trace of the function leap shows that recursive functions do not +necessarily produce ef(cid:2)cient implementations. The problem is that the function +remembers all previous argument values, even though it never needs them again. +To remember a potentially large number of old argument values is a source of in- +ef(cid:2)ciency that can, and should, be avoided. + +An ef(cid:2)cient implementation of a tail recursive function requires the use of a +loop. There are several loop constructs in C. For this problem, the while-statement +is the most appropriate. The other loop constructs will be described later in this +chapter, when we will also discuss how to select a loop construct appropriate to +the problem being solved. The while-loop is a statement that has the following +syntactical form: + +while( (cid:12) ) { + +} + +The purpose of the while-statement is to evaluate the expression (cid:12) +, and if this +yields true, to execute the statement(s) (cid:0) of the body. The evaluation of (cid:12) and +the execution of the body are repeated until the condition yields false. The body +should be constructed such that executing it should eventually lead to the con- +dition failing and the while-loop halting. As in the case of the if-statements, the +curly brackets are not necessary if the body of the while-loop consists of just one +statement. We will always use brackets though, to make the programs more main- +tainable. + +We now show a transformation for turning a tail recursive function such as +leap into a C function using a while-statement. Consider the following schematic +rendering of a tail recursive function with a single argument: +(*SML single argument tail recursion schema*) + +(* (cid:0) : (cid:1) -> (cid:1)(cid:5)(cid:6) *) +fun (cid:0)(cid:9)(cid:8) + += if (cid:12) + +then (cid:0) +else (cid:14) ; + +Revision: 6.41 + +(cid:0) +(cid:13) + 62 + +Chapter3. Loops + +is an argument of type (cid:1) . The (cid:12) + +Here the (cid:8) +, and (cid:14) represent expressions that may +. The type of the expression (cid:12) must be bool, the type of (cid:13) +contain occurrences of (cid:8) +must be (cid:1) , and the type of (cid:14) must be (cid:1)(cid:22)(cid:6) . No calls to (cid:0) must appear either directly or +indirectly in any of the expressions (cid:12) +. (Such cases will be discussed later +, and (cid:14) +in this chapter.) + +, (cid:13) + +, (cid:13) + +A function that can be expressed in the above form of the single argument tail +recursion schema can be implemented ef(cid:2)ciently using a C function with a while- +statement as shown schematically below: +/*C single argument while-schema*/ + +(cid:8) ) { + +(cid:0) ( (cid:1) +while( (cid:12) ) { +(cid:8) = (cid:13) ; + +} +return (cid:14) ; + +(cid:1)(cid:7)(cid:6) + +} + +The crucial statement is the assignment-statement (cid:8) =(cid:13) +. This is a command that ex- +plicitly alters the value associated with a cell in the store. When executed, the +assignment-statement computes the value of (cid:13) +, and updates the cell associated +immediately before the as- +with the argument (cid:8) +signment is used in the computation of (cid:13) +. After the update, the previous value is +lost. The new value is used during the next iteration, both by the condition and by +the assignment-statement. This amounts to the reuse of a store cell as suggested +by the leap example. + +. If (cid:8) occurs in (cid:13) + +, the value of (cid:8) + +Substitution of the schematic values from the table above into the single argu- + +ment while-schema yields an iterative C version of leap: + +int leap( int y ) { + +while( y % 4 != 0 ) { + +y = y+1 ; + +} +return y ; + +} + +Exercise 3.3 Show the correspondence between the SML and C versions of leap. + +Exercise 3.4 Modify the C function leap to deal with any year after 1582 using + +(3.1). + +The C version of leap uses the constructs that the typical C programmer would +use. We were able to construct this by using a systematic transformation from a +relatively straightforward SML function. This is interesting as some would con- +sider the iterative C version of leap as advanced. This is because the argument +y is reused as the result during the while-loop. To write such code requires the +programmer to be sure that the original value of the argument will not be needed +later. + +Revision: 6.41 + + 3.3. Whileloops + +63 + +An execution trace of this new version of leap is now in order (cid:2)rstly to see +what exactly the while-statement does and secondly to make sure that only a sin- +gle cell is needed. At Step 1 the iterative version of leap is called with the same +sample argument 1998 as before: + +int leap( int y ) { + +while( y % 4 != 0 ) { + +y : 1998 + +(Step 1) + +y = y+1 ; + +} +return y ; + +} + +At Step 2 the condition y % 4 != 0 is evaluated, which yields true. + +int leap( int y ) { + +while( y % 4 != 0 ) { + +y = y+1 ; + +} +return y ; + +} + +(Step 2) + +As a result, the assignment-statement y=y+1; is executed. This changes the value +associated with the cell for y to 1999. The previous value 1998 is now lost. No call +is made at this point, so no new cells are needed. The current y remains accessible. + +int leap( int y ) { + +while( y % 4 != 0 ) { + +y = y+1 ; + +} +return y ; + +} + +y : 1999 + +(Step 3) + +At Step 4 the condition is evaluated for the second time. The value associated with +y has changed, but its value, 1999, is still not divisible by 4. The condition thus +returns true again. + +int leap( int y ) { + +while( y % 4 != 0 ) { + +y = y+1 ; + +} +return y ; + +} + +(Step 4) + +At Step 5 the statement y=y+1; is executed for the second time. This changes the +value associated with y to 2000. Again, no new cell is required and y remains +accessible. + +Revision: 6.41 + +(cid:0) +(cid:0) +(cid:0) +(cid:0) + 64 + +Chapter3. Loops + +int leap( int y ) { + +while( y % 4 != 0 ) { + +y = y+1 ; + +} +return y ; + +} + +y : 2000 + +(Step 5) + +At Step 6 the condition is evaluated for the third time, yielding false because 2000 +is divisible by 4. This terminates the loop and gives control to the statement fol- +lowing the while-statement, which is the return statement. Thus the body of the +while-statement y=y+1; is not executed again. + +int leap( int y ) { + +while( y % 4 != 0 ) { + +y = y+1 ; + +} +return y ; + +} + +(Step 6) + +At Step 7 the function leap terminates: +statement is executed, returning the value 2000. + +the statement following the while- + +int leap( int y ) { + +while( y % 4 != 0 ) { + +y = y+1 ; + +} +return y ; + +} + +return 2000 + +(Step 7) + +The execution trace shows that only one cell is ever used. It also shows that the +conditional of the while-statement is evaluated three times. The body of the while- +statement y=y+1; is executed only twice. This is a general observation: +if, for +some +times, the body of the +while-statement is executed + +% , the conditional of a while is executed + +times. + +We have developed an ef(cid:2)cient and idiomatic C implementation of the leap +function on the basis of a systematic transformation, the while-schema. The while- +schema is of limited use because it cannot deal with functions that have more than +one argument. In the next section, the while-schema will be appropriately gener- +alised. + +3.3.2 Multiple argument tail recursion + +The function leap of the previous section has a single argument. This is too re- +strictive. For a recursive function with more than one argument, the while-schema +can be generalised. The standard method in functional programming for general- +izing a function with a single argument to one with many arguments is to treat the +collection of all arguments as a tuple. This tupling of the arguments brings a func- + +Revision: 6.41 + +(cid:0) +(cid:0) +(cid:0) +(cid:15) +(cid:12) +(cid:15) +(cid:2) +(cid:0) +(cid:15) + 3.3. Whileloops + +65 + +tion with more than one argument in the form below. We will call this tupling of +arguments the pre-processing of the multiple argument while-schema. +(*SML multiple argument tail recursion schema*) + +(* (cid:0) : ( (cid:1) +fun (cid:0) ( (cid:8)(cid:10)(cid:2) , ... (cid:8)(cid:11)(cid:4) ) + +(cid:2) * ... (cid:1) + +(cid:4) ) -> (cid:1) + +(cid:6) *) + += if (cid:12) + +then (cid:0) +else (cid:14) ; + +Here, (cid:8) + +(cid:2)(cid:11)(cid:16)(cid:18)(cid:16)(cid:18)(cid:16)(cid:3)(cid:8)(cid:20)(cid:4) are the arguments of types (cid:1) + +, and (cid:14) are now dependent on (cid:8)(cid:24)(cid:2)(cid:17)(cid:16)(cid:18)(cid:16)(cid:18)(cid:16)(cid:19)(cid:8)(cid:20)(cid:4) . No calls to (cid:0) + +must appear in any of the expressions (cid:12) + +, (cid:13) + +, and (cid:14) + +. + +(cid:2)(cid:23)(cid:16)(cid:18)(cid:16)(cid:21)(cid:16)(cid:22)(cid:1)(cid:7)(cid:4) respectively. The expressions (cid:12) + +, +, either directly or indirectly, + +It would have been nice if the corresponding generalisation of the while- + +schema could look like this. +/*C multiple argument while-schema*/ + +(cid:1)(cid:7)(cid:6) + +(cid:8)(cid:10)(cid:2) , ... (cid:1)(cid:5)(cid:4) + +(cid:0) ( (cid:1)(cid:3)(cid:2) +while( (cid:12) ) { + +(cid:8)(cid:20)(cid:4) ) { + +( (cid:8) + +(cid:2) , ... (cid:8)(cid:20)(cid:4) ) = (cid:13) ; + +} +return (cid:14) ; + +} + +Unfortunately the multiple assignment-statement is not supported by C: + +( (cid:8)(cid:10)(cid:2) , ... (cid:8)(cid:20)(cid:4) ) = (cid:13) ; /* incorrect C */ + +In one of the predecessors to the C language, BCPL, the multiple assignment was +syntactically correct. It is an unfortunate fact of life that useful concepts from an +earlier language are sometimes lost in a later language. Multiple assignment is in +C achieved by a number of separate single assignment-statements. Therefore to +produce a correct C function, we must do some post-processing. The transforma- +tion of a multiple assignment into a sequence of assignments is shown in the two +examples below. The (cid:2)rst example is an algorithm for computing the modulus of +two numbers. The second example uses Euclid’s algorithm to compute the great- +est common divisor of two numbers. + +Independent assignments + +The function modulus as shown below uses repeated subtraction for computing +the modulus of m with respect to n, where m and n both represent positive natural +numbers. + +(* modulus : int -> int -> int *) +fun modulus m n = if m >= n + +then modulus (m - n) n +else m : int ; + +This function has been written using a curried style, which is preferred by some +because curried functions can be partially applied. C does not offer curried func- +tions so we will need to transform the curried version of modulus into an uncur- + +Revision: 6.41 + +(cid:13) +(cid:13) + 66 + +Chapter3. Loops + +ried version (cid:2)rst. This requires the arguments to be grouped into a tuple as fol- +lows: + +(* modulus : int*int -> int *) +fun modulus (m,n) = if m >= n + +then modulus (m - n,n) +else m : int ; + +If you prefer to write functions directly with tupled arguments, you can save your- +self some work because the preparation above is then unnecessary.The correspon- +dence between the elements of the multiple argument while-schema and the ver- +sion of modulus with the tupled arguments is as follows: + +: +: + +schema: + +C +modulus +2 + +Functional +modulus +2 +(int*int) (int,int) +int +(cid:0) ): (m,n) + +int +(m,n) +m >= n + +m >= n +(m - n,n) (m - n,n) +m : int + +m + +( (cid:1)(cid:3)(cid:2) * (cid:1)(cid:1)(cid:0) ): +(cid:1)(cid:7)(cid:6) : +( (cid:8)(cid:10)(cid:2) , (cid:8) +: +: +: + +Filling in these correspondences in the multiple argument while-schema yields: + +int modulus( int m, int n ) { + +while( m >= n ) { + +(m,n) = (m - n,n) ; + +/*!*/ +} +return m ; + +} + +The /*!*/ marks a syntactically incorrect line. To turn this into correct C, the mul- +tiple assignment must be separated into a sequence of assignments. In this case +(but not in general (cid:150) see the section on Mutually dependent arguments below), we +can simply separate the two components of the tuples on the left and right hand +sides of the multiple assignment and assign them one by one as follows: + +(m,n) = (m - n,n) ; + +m = m - n ; +n = n ; + +The assignment-statement n=n; does nothing useful so we can safely remove it. +This yields the following C implementation of modulus: + +int modulus( int m, int n ) { + +while( m >= n ) { + +m = m - n ; + +} +return m ; + +} + +Revision: 6.41 + +(cid:0) +(cid:15) +(cid:12) +(cid:13) +(cid:14) + 3.3. Whileloops + +67 + +With the aid of the multiple argument while-schema, we have implemented an ef- +(cid:2)cient and idiomatic C function. The multiple argument while-schema requires +pre-processing of the SML function to group all arguments into a tuple, and it re- +quires post-processing of the C function to separate the elements of the tuple into +single assignment-statements. The pre-processing (tupling) is, to some extent, the +inverse of the post-processing (untupling). In this example, the post-processing +was particularly easy. This is not always the case, as the next example will show. + +Mutually dependent arguments + +Consider the function euclid from Chapter 2. To prepare for the multiple argu- +ment while-schema, the arguments of the function have already been grouped into +a tuple: + +(* euclid : int*int -> int *) +fun euclid (m,n) = if n > 0 + +then euclid (n,m mod n) +else m ; + +Exercise 3.5 Show the table of correspondence between the euclid function and + +the while-schema. + +The multiple argument while-schema yields: + +int euclid( int m, int n ) { + +while( n > 0 ) { + +(m,n) = (n,m % n) ; + +/*!*/ +} +return m ; + +} + +The line marked /*!*/ must again be transformed into a sequence of assign- +ments. It would be tempting to simply separate the two components of the tuples +on the left and right hand sides of the multiple assignment and assign them one +by one as follows: + +m = n ; +n = m % n ; + +/* WRONG */ + +This is wrong, because (cid:2)rst changing the value associated with m to that of n +would cause n to become 0 always. To see this, consider the following execution +trace. We are assuming that m and n are associated with some arbitrary values (cid:8) +and (cid:2) + +: + +m = n ; +n = m % n ; + +/* WRONG */ + +m: (cid:8) + +n: (cid:2) + +(Step 1) + +m = n ; +n = m % n ; + +/* WRONG */ + +m: (cid:2) + +n: (cid:2) + +(Step 2) + +Revision: 6.41 + +(cid:0) +(cid:0) + 68 + +Chapter3. Loops + +m = n ; +n = m % n ; + +/* WRONG */ (cid:0) + +m: (cid:2) + +n: % + +(Step 3) + +First assigning n and then m would not improve the situation. The problem is that +the two assignment statements are mutually dependent. The only correct solution +is to introduce a temporary variable, say old_n, as shown below. The temporary +variable serves to remember the current value in one of the cells involved, whilst +the value in that cell is being changed. + +int euclid( int m, int n ) { + +while( n > 0 ) { + +const int old_n = n ; +n = m % old_n ; +m = old_n ; + +} +return m ; + +} + +The declaration of old_n above is a local constant declaration rather than a local +variable declaration. This is sensible because old_n is not changed in the block in +which it is declared. We are making use of the fact that the local variables and con- +stants of a block exist only whilst the statements of the block are being executed. +So each time round the while-loop a new version of old_n is created, initialised, +used twice and then discarded. The cell is never updated, so it is a constant. + +The multi-argument while-schema gives us an ef(cid:2)cient and correct C im- +plementation of Euclid’s greatest common divisor algorithm. As we shall see, +since most functions have no mutual dependencies in the multiple assignment- +statement, the post-processing is thus often quite straightforward. + +Exercise 3.6 Trace the execution of euclid(9,6) using the iterative version of + +euclid above. + +3.3.3 Non-tail recursion: factorial + +Not all functions are tail recursive. To investigate the rami(cid:2)cations of this fact on +our ability to code ef(cid:2)cient and idiomatic C functions, let us consider an example: +the factorial function. + +(cid:8)(cid:5)(cid:9) + +(3.3) + +We have seen the recursive SML function to compute the factorial before: + +(* fac : int -> int *) +fun fac n = if n > 1 + +then n * fac (n-1) +else 1 ; + +Revision: 6.41 + +(cid:3) +(cid:1) +(cid:0) +(cid:2) +(cid:4) +(cid:10) +(cid:2) +(cid:4) +(cid:15) +(cid:1) +(cid:0) +(cid:4) +(cid:7) +(cid:2) +(cid:0) + 3.3. Whileloops + +69 + +Exercise (cid:0) 3.7 Prove by induction over n that n (cid:1) + +(cid:0) fac n. + +The corresponding C version of the factorial function is: + +int fac( int n ) { +if( n > 1 ) { + +return n * fac (n-1) ; + +} else { + +return 1 ; + +} + +} + +Let us now trace the execution of fac(3) to study the ef(cid:2)ciency of the C code. At +Step 1 the function fac is entered. + +int fac( int n ) { +if( n > 1 ) { + +return n * fac (n-1) ; + +n : 3 + +(Step 1) + +} else { + +return 1 ; + +} + +} + +The test n > 1 yields true because n is associated with the value 3, so that at +Step 2 the then-branch of the conditional is chosen. + +int fac( int n ) { +if( n > 1 ) { + +return n * fac (n-1) ; + +} else { + +return 1 ; + +} + +} + +(Step 2) + +This causes a call to be made to fac(2) at Step 3. The number 3 will have to be +remembered for later use when fac(2) has delivered a value that can be used for +the multiplication. + +n : 2 +n(cid:146) + +: 3 + +(Step 3) + +int fac( int n ) { +if( n > 1 ) { + +return n * fac (n-1) ; + +} else { + +return 1 ; + +} + +} + +At Step 4 the new value of n is tested, yielding true again. + +Revision: 6.41 + +(cid:0) +(cid:0) +(cid:0) + 70 + +Chapter3. Loops + +int fac( int n ) { +if( n > 1 ) { + +return n * fac (n-1) ; + +} else { + +return 1 ; + +} + +} + +(Step 4) + +This causes another call to be made, this time to fac(1) at Step 5. The number 2 +will have to be remembered for use later, just like the number 3. + +n : 1 +n(cid:146) +n(cid:146) + +: 2 + +: 3 + +(Step 5) + +int fac( int n ) { +if( n > 1 ) { + +return n * fac (n-1) ; + +} else { + +return 1 ; + +} + +} + +At Step 6 the new value of n is tested, yielding false. + +int fac( int n ) { +if( n > 1 ) { + +return n * fac (n-1) ; + +} else { + +return 1 ; + +} + +} + +(Step 6) + +At Step 7 the most recent call returns 1. + +int fac( int n ) { +if( n > 1 ) { + +return n * fac (n-1) ; + +} else { + +return 1 ; + +} + +} + +return 1 +n : 2 +n(cid:146) + +: 3 + +(Step 7) + +At Step 8 the second call returns 2, which is calculated from the return value of +Step 7 and the saved value of n. + +Revision: 6.41 + +(cid:0) +(cid:0) +(cid:146) +(cid:0) +(cid:0) + 3.3. Whileloops + +71 + +int fac( int n ) { +if( n > 1 ) { + +return n * fac (n-1) ; + +} else { + +return 1 ; + +} + +} + +Finally, at Step 9 the (cid:2)rst call returns 6. + +int fac( int n ) { +if( n > 1 ) { + +return n * fac (n-1) ; + +} else { + +return 1 ; + +} + +} + +return 2 +n : 3 + +(Step 8) + +return 6 + +(Step 9) + +Summarising, because the function fac is not tail recursive, we have the following +ef(cid:2)ciency problem: + +(cid:15)2(cid:14)(cid:16)(cid:15) + +(cid:1) Firstly, the fac function generates the values + +(cid:16)(cid:21)(cid:16)(cid:18)(cid:16) + +(cid:0) on entry to the + +recursion. + +(cid:15)2(cid:14)(cid:16)(cid:15) + +(cid:1) All values +the store. + +(cid:16)(cid:18)(cid:16)(cid:18)(cid:16) + +(cid:0) have to be remembered, which requires + +cells in + +(cid:1) Finally all values are multiplied on exit from the recursion. + +This can be symbolised as: + +(cid:1)1(cid:15) + +(cid:16)(cid:18)(cid:16)(cid:21)(cid:16) + +(cid:16)(cid:18)(cid:16)(cid:18)(cid:16) + +can be multiplied to some number, the +Here, the parentheses signify that, before +latter must be computed (cid:2)rst. The ef(cid:2)ciency of the implementation can be im- +proved if previous numbers do not have to be remembered. This is possible as +multiplication is an associative operator. Therefore we have: + +(cid:1)1(cid:15) + +(cid:1)(cid:13)(cid:15) + +(cid:16)(cid:18)(cid:16)(cid:18)(cid:16) + +(cid:16)(cid:18)(cid:16)(cid:18)(cid:16) + +(cid:14)(cid:16)(cid:15) + +can be +Now there is no need to remember the numbers +multiplied immediately by +(cid:6) , +and so on. The successive argument values for the (cid:1) operator can be generated and +used immediately. The only value that needs to be remembered is the accumulated +result. This corresponds to multiplying on entry to the recursion. + +(cid:0) . This in turn can be multiplied directly by + +(cid:16)(cid:18)(cid:16)(cid:18)(cid:16) . The number + +Revision: 6.41 + +(cid:0) +(cid:0) +(cid:0) +(cid:0) +(cid:14) +(cid:2) +(cid:14) +(cid:6) +(cid:14) +(cid:0) +(cid:0) +(cid:14) +(cid:2) +(cid:14) +(cid:6) +(cid:14) +(cid:15) +(cid:3) +(cid:1) +(cid:0) +(cid:2) +(cid:4) +(cid:10) +(cid:2) +(cid:4) +(cid:15) +(cid:1) +(cid:0) +(cid:15) +(cid:5) +(cid:1) +(cid:0) +(cid:0) +(cid:8) +(cid:5) +(cid:1) +(cid:2) +(cid:5) +(cid:1) +(cid:6) +(cid:5) +(cid:0) +(cid:8) +(cid:8) +(cid:8) +(cid:15) +(cid:3) +(cid:1) +(cid:0) +(cid:2) +(cid:4) +(cid:10) +(cid:2) +(cid:4) +(cid:15) +(cid:1) +(cid:0) +(cid:1) +(cid:1) +(cid:5) +(cid:0) +(cid:0) +(cid:8) +(cid:8) +(cid:5) +(cid:2) +(cid:8) +(cid:5) +(cid:6) +(cid:8) +(cid:5) +(cid:0) +(cid:15) +(cid:0) +(cid:0) +(cid:15) +(cid:15) +(cid:0) +(cid:15) +(cid:0) + 72 + +Chapter3. Loops + +Using an accumulating argument is a standard functional programming tech- +nique. Here is a function fac_accu that uses the accumulating argument tech- +nique. + +(* fac_accu : int -> int -> int *) +fun fac_accu n b = if n > 1 + +then fac_accu (n-1) (n*b) +else b ; + +Exercise (cid:0) 3.8 Prove by induction over n that for all natural numbers b the fol- +fac_accu n b. Then conclude that + +lowing equality holds: b * n (cid:1) +n (cid:1) + +(cid:0) fac_accu n 1. + +Exercise 3.9 Show the correspondence between the SML program and the while- + +schema. + +The function fac_accu is is tail recursive. It can therefore be implemented in C +using a while-loop: + +int fac_accu( int n, int b ) { + +while( n > 1 ) { + +(n,b) = (n-1,n*b) ; + +/*!*/ +} +return b ; + +} + +The multiple assignment can be replaced by two separate assignment-statements +as there is no mutual dependency between the two resulting assignments. They +must be properly ordered, so that n is used before it is changed: + +int fac_accu( int n, int b ) { + +while( n > 1 ) { + +b = n*b ; +n = n-1 ; + +} +return b ; + +} + +This shows that tail recursion, and therefore loops, can be introduced by using an +accumulating argument. It is not always easy to do this and it requires creativity +and ad hoc reasoning. In the case of the factorial problem, we had to make use of +the fact that multiplication is an associative operation. In other cases shown later, +similar reasoning is necessary. + +The resulting version fac_accu of the factorial is slightly odd. It has two ar- +guments: the (cid:2)rst argument is the number from which the factorial is to be com- +puted, the second number should always be one. A more useful version of facto- +rial would have only one argument: + +int fac( int n ) { + +return fac_accu( n, 1 ) ; + +} + +Revision: 6.41 + +(cid:0) + 3.3. Whileloops + +73 + +This is neither the most ef(cid:2)cient nor the most readable version of fac, the function +fac_accu is a specialised function and is probably never called from any other +function. In that case we can inline functions: we can amalgamate the code of two +functions to form one function that performs the whole task. This is more ef(cid:2)cient +and it improves the readability of the code. Inlining is a seemingly trivial opera- +tion: we replace a function call in the caller with the body of the called function, +that is, the callee. However, there are some potential pitfalls: + +1. The C language does not provide good support for literal substitution. Spe- +cial care has to be taken with a return statement in the callee. After inlining +in the caller, the return statement will now exit the caller instead of the callee. + +2. Names of variables might clash. Variables have to be renamed in order to + +preserve the meaning of the program. + +3. Function arguments are passed by value. This means that the callee can +change its argument without the caller noticing. After inlining, the changes +become visible to the caller. This might require the introduction of local vari- +ables + +In the case of factorial, the inlining operation results in the following code: + +int fac( int n ) { + +int b = 1 ; +while( n > 1 ) { + +b = n*b ; +n = n-1 ; + +} +return b ; + +} + +Because the argument b of fac_accu was changed, we needed to introduce a lo- +cal variable. The local variable is initialised to 1. + +Other places where local variables are introduced are as a replacement for the +let clauses in SML. Any expression that has been given a name with a let is +in general programmed with a local variable in C. This will be shown in the next +section where local variables are used extensively. Over the course of this chapter, +more functions will be inlined to show how to compose larger C functions. + +3.3.4 More on assignments + +Many of the while loops will have assignments with the following patttern: + +(cid:8) = (cid:8)(cid:1)(cid:0) + +(cid:2) ; + +Here, (cid:0) +ments in the while loop of fac above: + +stands for one of the possible C operators. Examples include both assign- + +b = n*b ; +n = n-1 ; + +Revision: 6.41 + + 74 + +Chapter3. Loops + +Because these patterns are so common, C has special assignment operators to deal +with these patterns. Any assignment of the pattern above can be written using +one of the assignment operators *=, /=, %=, +=, -=, <<=, >>=, &=, |=, and ˆ=. +The assignments below have equivalent semantics. Here (cid:8) +is a variable and (cid:2) an +expression of the appropriate type. + +(cid:8) = (cid:8) + +(cid:2) ; + +(cid:0) = (cid:2) ; + +This is the case for any of the operators *, /, %, +, -, <<, >>, &, |, and ˆ. Thus +i=i+2 and i+=2 (read: add 2 to i) are equivalent, and so are j=j/2 and j/=2 +(read: divide j by 2). + +Using these assignment operators has two advantages. Firstly, they clarify the +meaning of the code, as j/=2 means divide j by two as opposed to (cid:2)nd the cur- +rent value of j, divide it by two, and store it in j (which is by coincidence the same +variable). The second advantage is a software engineering advantage; when more +complex variables are introduced, these operators take care that the variable is +speci(cid:2)ed only once. An example of this is shown in Chapter 5. + +Each assignment operation is actually an expressions in itself. + +For exam- +ple, j/=2 divides j by two and results in this value. Therefore the expression +i += j /= 2 means divide j by two and add the result of that operation to i. +Assignments placed in the middle of expressions can cause errors as the order +of assignments is unde(cid:2)ned. It is recommended to use the assignment only as a +statement. + +As a (cid:2)nal abbreviation, there are special operators for the patterns (cid:0) += 1 and +(cid:0) -= 1, denoted (cid:0) ++ and (cid:0) --, also known as the increment and decrement op- +erators. They exist in two different forms: the pre-increment ++ (cid:0) and the post- +increment (cid:0) ++. The (cid:2)rst version is identical to (cid:0) +=1 or (cid:0) = (cid:0) +1: add one to (cid:0) and use +the resulting value as the value of the expression ++ (cid:0) . The post-increment means +add one to (cid:0) , but use the old, non-incremented value as the value of the expression. +Similarly, -- + +has a value one lower than + +--. + +A common use of the -- operator is inside a while condition: + +int absurd_fac( int n ) { + +int b = n ; +while( --n ) { +b = n*b ; + +} +return b ; + +} + +The statement while( --n ) violates all rules of decency. There is a side ef- +fect in the expression (the -- operator), and the resulting value is interpreted as +a boolean (which means an implicit test against zero). This works because any in- +teger which is not zero indicates true, while only zero indicates false. This par- +ticular version of fac is not robust, the loop will iterate inde(cid:2)nitely if n happens +to have the value 0. + +Revision: 6.41 + +(cid:0) +(cid:8) +(cid:15) +(cid:15) + 3.3. Whileloops + +75 + +3.3.5 Breaking out of while-loops + +We are now ready to tackle the most general case of turning a tail recursive func- +tion into an ef(cid:2)cient loop. Consider the function bisection from Chapter 2. This +poses the following problems to the while-schema: the recursion has two termina- +tion points (see the lines marked 1 and 2) and it can continue in two different ways +(lines marked 3 and 4). + +(* bisection : (real->real) -> real -> real -> real *) +fun bisection f l h + += let + +in + +(* 1 *) + +(* 2 *) + +(* 3 *) +(* 4 *) + +val m = (l + h) / 2.0 +val f_m = f m + +if absolute f_m < eps + +then m +else if absolute (h-l) < delta + +then m +else if f_m < 0.0 + +then bisection f m h +else bisection f l m + +end ; + +The third and last version of the while-schema that we are about to see will be +fully general. It takes into account: + +(cid:1) Multiple termination points based on arbitrary predicates. + +(cid:1) Multiple continuation points based on arbitrary predicates. + +(cid:1) An arbitrary ordering of termination- and continuation-points. + +(cid:1) Local de(cid:2)nitions. + +(*SML general tail recursion schema*) + +(* (cid:0) : ( (cid:1)(cid:3)(cid:2) * ... (cid:1)(cid:5)(cid:4) ) -> (cid:1)(cid:5)(cid:6) *) +fun (cid:0) ( (cid:8)(cid:10)(cid:2) , ... (cid:8)(cid:11)(cid:4) ) + += let + +val (cid:2) +... +val (cid:2) + +if (cid:12) + +in + +(cid:2) = + +(cid:2) (* (cid:2) + +(cid:2) : (cid:1) + +*) + +(cid:2)(cid:1) = + +(cid:1) (* (cid:2) + +(cid:3)(cid:1) : (cid:1) + +(cid:0)(cid:5)(cid:4) *) + +then (cid:6) +else + +... +if (cid:12) + +then (cid:6) +else (cid:6) + +end ; + +Revision: 6.41 + +(cid:5) +(cid:0) +(cid:6) +(cid:5) +(cid:2) +(cid:2) +(cid:1) +(cid:1) +(cid:1) +(cid:1) +(cid:2) + 76 + +Chapter3. Loops + +(cid:2)(cid:17)(cid:16)(cid:18)(cid:16)(cid:18)(cid:16) + +(cid:2)(cid:17)(cid:16)(cid:18)(cid:16)(cid:18)(cid:16)(cid:19)(cid:8)(cid:20)(cid:4) are the arguments of (cid:0) + +(cid:2)(cid:1) ; their values are the expressions + +, their types are (cid:1)(cid:21)(cid:2)(cid:17)(cid:16)(cid:18)(cid:16)(cid:21)(cid:16)(cid:22)(cid:1)(cid:7)(cid:4) respectively. The local +The (cid:8) +(cid:1) , and their types +variables of (cid:0) are (cid:2) +are predicates over the argu- +are (cid:1) +ments and the local variables. The (cid:6) +(cid:2) are expressions that may take one of +two forms. This form decides whether the present branch in the conditional is a +termination or a continuation point: + +(cid:0)(cid:5)(cid:4) respectively. The expressions (cid:12) + +(cid:2)(cid:17)(cid:16)(cid:18)(cid:16)(cid:18)(cid:16) + +(cid:2)(cid:17)(cid:16)(cid:18)(cid:16)(cid:18)(cid:16) + +(cid:16)(cid:18)(cid:16)(cid:18)(cid:16)(cid:20)(cid:1) + +(cid:16)(cid:18)(cid:16)(cid:18)(cid:16) + +continuation The form of (cid:6) + +(cid:8) , which means that the recursion on (cid:0) may be +continued from here with new values for the arguments as computed by the +(cid:8) must be of type ( (cid:1) +expression (cid:13) + +(cid:8) . In this case, (cid:13) + +(cid:2) * . . . (cid:1) + +(cid:8) is (cid:0) + +(cid:4) ). + +termination The form of (cid:6) + +(cid:8) is (cid:14) + +nate here. The function result is delivered by the expression (cid:14) + +(cid:8) , which means that the recursion on (cid:0) may termi- +(cid:8) . In this case, + +(cid:8) must be of type (cid:1)(cid:19)(cid:6) . + +(cid:8) and (cid:14) + +The (cid:13) +(cid:8) are all expressions ranging over the arguments and local variables. +The only calls permitted to (cid:0) are those explicitly listed in the continuation case +above. + +The general while-schema that corresponds to the general tail recursion + +schema is: +/*C general while-schema*/ +(cid:8)(cid:10)(cid:2) , ... (cid:1)(cid:5)(cid:4) + +(cid:8)(cid:20)(cid:4) ) { + +(cid:0) ( (cid:1)(cid:3)(cid:2) + +(cid:1)(cid:7)(cid:6) + +(cid:2) ; + +... + +(cid:2)(cid:1) ; + +while( true ) { + +(cid:2) ; + +(cid:2) = +... +(cid:1) ; +(cid:2)(cid:1) = +if( (cid:12) +(cid:2) ) (cid:6) +else if( (cid:12) +... +else if( (cid:12) +else (cid:6) + +(cid:2) ; + +(cid:2) ; +(cid:0) ) (cid:6) + +(cid:0) ; + +) (cid:6) + +; + +} + +} + +The loop is now in principle an endless loop, which can be terminated only by +(cid:8) ;. Depending on the form of the +one of the conditional statements if( (cid:12) +in the general while- + +in the general tail recursion schema, the corresponding (cid:6) + +(cid:8) ) (cid:6) + +schema will have one of two forms: + +continuation For a continuation point, the form of (cid:6) +(cid:8)(cid:20)(cid:4) )=(cid:13) + +(cid:8) will be a multiple assign- +(cid:8) ;}. The loop will be reexecuted with new values + +(cid:2) , . . . + +ment { ( (cid:8) +for (cid:8)(cid:10)(cid:2)(cid:10)(cid:16)(cid:21)(cid:16)(cid:18)(cid:16)(cid:22)(cid:8)(cid:20)(cid:4) . + +termination For a termination point, the form of (cid:6) + +is { return (cid:14) + +(cid:8) ;}. This + +causes the loop (and the function (cid:0) ) to terminate. + +Revision: 6.41 + +(cid:2) +(cid:5) +(cid:5) +(cid:0) +(cid:6) +(cid:2) +(cid:12) +(cid:1) +(cid:6) +(cid:1) +(cid:1) +(cid:13) +(cid:14) +(cid:1) +(cid:0) +(cid:6) +(cid:2) +(cid:1) +(cid:0) +(cid:4) +(cid:2) +(cid:2) +(cid:5) +(cid:2) +(cid:5) +(cid:1) +(cid:1) +(cid:1) +(cid:1) +(cid:6) +(cid:8) +(cid:8) +(cid:8) + 3.3. Whileloops + +77 + +It is important not to mix up termination and continuation points. They should be +carefully identi(cid:2)ed in the general tail recursion schema, and the correspondence +with the general while-schema should be maintained. + +To apply the general while-schema to the bisection function, the arguments +must be grouped in a tuple as usual. Furthermore, the types of the local variables +m and f_m must be indicated. This yields: + +(* bisection : (real->real)*real*real -> real *) +fun bisection(f,l,h) + += let + +in + +(* 1 *) + +(* 2 *) + +(* 3 *) +(* 4 *) + +val m = (l + h) / 2.0 (* m +val f_m = f m + +: real *) +(* f_m : real *) + +if absolute f_m < eps + +then m +else if absolute (h-l) < delta + +then m +else if f_m < 0.0 + +then bisection(f,m,h) +else bisection(f,l,m) + +end ; + +Cases 1 and 2 are the termination cases, and 3 and 4 are the continuation cases. +The correspondence between the schema and the elements of the functions is: + +schema: + +: +: +( (cid:1)(cid:3)(cid:2) * +(cid:1)(cid:1)(cid:0) * (cid:1) + +): + +Functional +bisection +3 +(real->real* +real*real) + +real + +(cid:2) , (cid:8) + +(cid:0) , (cid:8) + +): f,l,h + +C +bisection +3 +(double(*)(double), + +double,double) + +double +f,l,h +absolute(f_m) < eps + +< eps + +absolute f_m +absolute (h-l) < delta absolute(h-l) < delta +f_m < 0.0 +m +m +(f,m,h) +(f,l,m) +real +real +m +f_m +(l + h) / 2 +f m + +f_m < 0.0 +{ return m ;} +{ return m ;} +{ (f,l,h)=(f,m,h) ;} +{ (f,l,h)=(f,l,m) ;} +double +double +m +f_m +(l + h) / 2 +f(m) + +(cid:1)(cid:7)(cid:6) + +( (cid:8) + +(cid:2) : +(cid:0) : +: +(cid:14)(cid:10)(cid:2) : +(cid:0) : +: +: +: +(cid:0) : +(cid:2) : +(cid:0) : +(cid:2) : +(cid:0) : + +In the multiple assignment statement (f,l,h)=(f,m,h); only the l is changed +and in the statement (f,l,h)=(f,l,m); it is only h that is changed. Thus we + +Revision: 6.41 + +(cid:0) +(cid:15) +(cid:5) +(cid:5) +(cid:12) +(cid:12) +(cid:12) +(cid:5) +(cid:14) +(cid:13) +(cid:5) +(cid:13) +(cid:3) +(cid:1) +(cid:0) +(cid:6) +(cid:1) +(cid:0) +(cid:2) +(cid:2) +(cid:5) +(cid:5) + 78 + +Chapter3. Loops + +may write l=m; and h=m; respectively. This gives the following C version: + +double bisection( double(*f)( double ), + +double l, double h ) { + +double m ; +double f_m ; +while( true ) { + +m = (l+h)/2.0 ; +f_m = f(m) ; +if( absolute( f_m ) < eps ) { + +return m ; + +} else if( absolute( h-l ) < delta ) { + +return m ; + +} else if( f_m < 0.0 ) { + +l = m ; + +} else { + +h = m ; + +} + +} + +} + +What we have done so far is to systematically transform an SML function with +multiple exits, multiple continuation points, local declarations, and multiple argu- +ments into a C function. Let us now re(cid:3)ect on the C function that we have derived. +Worth noting is the use of the condition true in the while-statement. This creates +in principle an ‘endless’ loop. It signals that there is no simple condition for decid- +ing when the loop should be terminated. + +Exercise 3.10 Complete the skeleton below by giving the contents of the body of the +while-loop. Comment on the ef(cid:2)ciency and the elegance of the implementa- +tion. + +double bisection( double(*f)( double ), + +double l, double h ) { + +double m = (l+h)/2.0 ; +double f_m = f(m) ; +while( ! ( absolute( f_m ) < eps || + +absolute( h-l ) < delta) ) { + +/*C body of the while-loop*/ + +} +return m ; + +} + +Some books on programming in C regard loops with multiple exits an advanced +feature. We prefer the multiple exit over a loop with one single complex termina- +tion condition. The SML program has guided us immediately to an ef(cid:2)cient and +readable C version. + +Revision: 6.41 + + 3.4. Forloops + +79 + +Two methods have been shown for breaking out of a while-loop: the condition +of the while-loop can become false, or a return statement can be executed (which +terminates the function and therefore the while-loop). C offers a third method, the +break-statement. Whenever a break is executed, a while-loop is terminated, and +execution resumes with the statement immediately following the while-loop. + +We do not need a break statement in any of these examples because the func- +tions contain only a single while-loop. However, when functions are inlined to +make larger entities, it might be necessary to break out of a loop in a callee to avoid +terminating the caller. Inserting a break statement will do the trick in that case. A +break will only jump out of the closest while loop, breaking about multiple while +loops is not possible, normally a return is used in that case. + +Exercise 3.11 Inline the function bisection in the following main program: + +int main( void ) { + +double x = bisection( parabola, 0.0, 2.0 ) ; +printf("The answer is %f\n", x ) ; +return 0 ; + +} + +What is the problem? What is the solution? + +We have now completed the treatment of the while-statement as a means to im- +plement recursive functions as ef(cid:2)cient and idiomatic C functions. The differ- +ent forms of the while-schema provide useful techniques for constructing these +C functions. C provides another useful loop construct, the for-loop, which is the +subject of the next section. + +3.4 For loops + +C offers various different kinds of loop structure. The while-statement is the +most general loop structure. A more speci(cid:2)c but useful loop-structure is the for- +statement. To see why the for-statement is useful, consider again the speci(cid:2)cation +of the factorial function (cid:1) : + +(cid:8)(cid:5)(cid:9) + +, and so on, until it reaches + +(cid:1) starts by generating the value (cid:0) and steps through the val- +. The (cid:10) operator has built-in knowledge about + +The computation of +ues (cid:6) , +the following: + +(cid:1) evaluate and accumulate the values of the expression (here just (cid:0) ), with the + +index (cid:0) bound to a sequence of values. + +the sequence of values is generated, starting with (cid:0) +value of (cid:0) by (cid:0) and ending at the value (cid:0) + +. + +(cid:0) , incrementing the + +Revision: 6.41 + +(cid:3) +(cid:1) +(cid:0) +(cid:2) +(cid:4) +(cid:10) +(cid:2) +(cid:4) +(cid:15) +(cid:1) +(cid:0) +(cid:4) +(cid:7) +(cid:2) +(cid:0) +(cid:15) +(cid:2) +(cid:15) +(cid:1) +(cid:0) +(cid:0) +(cid:15) + 80 + +Chapter3. Loops + +operator has a direct functional equivalent with a list, where the list is +. Let us digress brie(cid:3)y + +The (cid:10) +purely an arithmetic sequence of the numbers (cid:0) +on the use of lists and arithmetic sequences. + +through + +In many functional languages, arithmetic sequences are part of the language. +It is possible to de(cid:2)ne an SML operator -- that has the functionality of an arith- +metic sequence. We wish to be able to generate both increasing and decreasing +sequences: + +(* -- : int*int -> int list *) +infixr 5 -- ; +fun (m -- n) += let + +fun up + +i = if i > n + +then [] +else i :: up (i+1) + +fun down i = if i < n + +then [] +else i :: down (i-1) + +in + +if m <= n + +then up +m +else down m + +end ; + +With this de(cid:2)nition we can create the following lists: + +(1--3) = [1,2,3] ; +(0--0) = [0] ; +(1--0) = [1,0] ; + +The -- operator is quite a useful operator, but unfortunately, it is not part of the +standard libraries of SML. It is used by other authors such as Wikstr¤om [16] in his +text book on SML, and we shall make extensive use of it here. + +Using --, the arithmetic sequence operator fac can be written as follows: + +(* fac : int -> int *) +fun fac n = prod (1--n) ; + +The difference between the mathematical and the functional version of fac is that +the function prod is not concerned with the generation of the index values; the +processes of generating the indices and accumulating the product are completely +separated in the functional program. This is the principle of the separation of con- +cerns: issues that can be separated should be separated. The separation makes it +straightforward, for example, to replace prod by sum to compute the sum of the +numbers rather than their product. The same mechanism of generating the num- +bers would be used in either case. + +To make use of the separation of generating indices and accumulating the +product, a further investigation of the nature of the prod operator is useful. The +list operation prod is usually de(cid:2)ned in terms of the higher order function foldl: + +Revision: 6.41 + +(cid:15) + 3.4. Forloops + +81 + +(* foldl : ((cid:146)a->(cid:146)b->(cid:146)a) +fun foldl f r [] + += r +| foldl f r (x::xs) = foldl f (f r x) xs ; + +-> (cid:146)a -> (cid:146)b list -> (cid:146)a *) + +The function foldl is similar to the standard SML function revfold, but it is not +the same. The arguments are in a different order, and our (cid:2)rst argument f is a cur- +ried function. We prefer to use the name foldl because it is the standard name +for this function in virtually all other functional programming languages. Further- +more, adopting the name foldl makes it possible to give a consistent name to its +dual function foldr, which is equivalent to fold in SML. We will be needing +foldr in the next section, where we will also give its de(cid:2)nition. + +Returning to our example and the prod operator, we can now give the de(cid:2)ni- + +tion of the latter using foldl: + +(* prod : int list -> int *) +fun prod xs = foldl mul 1 xs ; + +The auxiliary function mul is just the curried version of the multiplication opera- +tor *: + +(* mul : int -> int -> int *) +fun mul x y = x * y : int ; + +Let us now investigate how prod works. When given a list, foldl returns an +expression with the elements of the list folded into a new value. The folding is +done using an accumulation function, mul in this case. Therefore, the factorial func- +tion causes the following transformations to be made (using a three element list for +convenience): + +foldl mul 1 + +(1 :: (2 :: (3 :: []))) + +((( +(( +( + +1 +1 +2 +6 + +* 1) * 2) * 3) +* 2) * 3) +* 3) + +The folding is shown schematically as the multiplications 1*1=1, 1*2=2, and +2*3=6. The diagram shows that, once the numbers have been generated, they can +be accumulated into a product. The numbers are never needed again. The pat- +tern of computation above is so common that it is worthwhile to introduce a new +schema. This foldl-schema operates on a de(cid:2)nition of the following form: +(*SML foldl schema*) +(* (cid:0) : (cid:1)(cid:3)(cid:2) -> ... -> (cid:1) +fun (cid:0)(cid:9)(cid:8)(cid:10)(cid:2) ... (cid:8) += foldl (cid:13) + +(cid:1) -> (cid:1)(cid:7)(cid:6) *) + +) ; + +(cid:1) ( + +-- + +(cid:16)(cid:18)(cid:16)(cid:18)(cid:16)(cid:19)(cid:8) + +(cid:1) are variables of types (cid:1) + +Here the (cid:8) +resents a function of type (cid:1) +expressions of type int. The variables (cid:8)(cid:24)(cid:2)(cid:23)(cid:16)(cid:18)(cid:16)(cid:18)(cid:16)(cid:3)(cid:8) +(cid:1) , +. The function name (cid:0) +, and +equals sign. + +(cid:6) -> int -> (cid:1) + +is an expression that rep- +are +, +should not occur on the right hand side of the + +(cid:1) may occur in the expressions (cid:13) + +is of type (cid:1) + +(cid:1) . The (cid:13) + +(cid:6) , the (cid:1) + +(cid:6) , and + +and + +(cid:16)(cid:18)(cid:16)(cid:18)(cid:16)(cid:22)(cid:1) + +Revision: 6.41 + +(cid:0) +(cid:0) +(cid:0) +(cid:0) +(cid:0) +(cid:0) +(cid:0) +(cid:0) +(cid:0) +(cid:1) +(cid:12) +(cid:15) +(cid:2) +(cid:2) +(cid:12) +(cid:15) +(cid:12) +(cid:15) + 82 + +Chapter3. Loops + +If + +, the C implementation of the foldl-schema contains an increasing for- + +statement, that is, one that counts upwards: +/*C increasing for schema*/ +(cid:8)(cid:10)(cid:2) , ... (cid:1) + +(cid:1) ) { + +(cid:1)(cid:7)(cid:6) + +(cid:0) ( (cid:1)(cid:3)(cid:2) +int (cid:0) ; +(cid:1)(cid:5)(cid:6)(cid:1)(cid:0) = (cid:1) ; +for( (cid:0) = + +; (cid:0) <= +(cid:0) = (cid:13) ( (cid:0) , (cid:0) ) ; + +; (cid:0) ++ ) { + +} +return (cid:0) ; + +} + +The for-statement has the following elements: + +(cid:1) The index (cid:0) which acts as the loop counter. It must be declared explicitly. + +(cid:1) An initialisation expression, (cid:0) = + +; in this example, which gives the index its + +initial value. + +(cid:1) A boolean expression to test for termination, (cid:0) <= + +in this example. The + +loop body (see below) is entered for as long as the condition is true. + +(cid:1) An iteration expression, (cid:0) ++ in this example, which is executed after the loop +body to increment the index. The operator ++ means increment the variable. + +(cid:1) A loop body statement (cid:0) =(cid:13) ( (cid:0) , (cid:0) );, which, using the index (cid:0) , does the +actual work. This consists of accumulating the results of the loop in the accu- +mulator (cid:0) + +. + +The for-statement in the for-schema is preceded by two declarations. The (cid:2)rst de- +clares the index (cid:0) . It is not necessary to give the index an initial value as the for- +statement will do that. The second declaration (cid:1)(cid:3)(cid:6)(cid:2)(cid:0) = (cid:1) ; declares the accumulator +for the loop. The accumulator must be initialised properly. The accumulator is up- +dated in the loop, using the values generated by the index and the current value +of the accumulator. + +When instantiating the increasing for-schema, it is best to choose names for (cid:0) +and (cid:0) that do not already occur in the function that is being created. In particular +one should avoid the names of the arguments of the function. + +If + +, then the C implementation of the for-schema contains a decreasing + +for-statement, that is, one that counts downwards: +/*C decreasing for schema*/ +(cid:2) , ... (cid:1) + +(cid:1) ) { + +(cid:0) ( (cid:1) +int (cid:0) ; + +(cid:0) = (cid:1) ; + +for( (cid:0) = + +; (cid:0) >= +(cid:0) = (cid:13) ( (cid:0) , (cid:0) ) ; + +} +return (cid:0) ; + +} + +; (cid:0) -- ) { + +Revision: 6.41 + +(cid:12) +(cid:10) +(cid:15) +(cid:1) +(cid:8) +(cid:12) +(cid:15) +(cid:12) +(cid:15) +(cid:12) +, +(cid:15) +(cid:1) +(cid:6) +(cid:2) +(cid:8) +(cid:1) +(cid:8) +(cid:1) +(cid:6) +(cid:12) +(cid:15) + 3.4. Forloops + +83 + +The differences between the increasing and the decreasing for loops are in their +test for termination and the iteration expression: + +In the decreasing case, the test for termination tests on greater or equal, +(cid:0) >= + +. + +(cid:1) The iteration expression is now a decrement: (cid:0) --. + +3.4.1 Factorial using a for-loop + +The increasing for-schema can be applied after substitution of the de(cid:2)nition of +prod in that of fac. This yields the following explicitly folding version of fac: + +(* fac : int -> int *) +fun fac n = foldl mul 1 (1--n) ; + +The correspondence between the foldl-schema, the increasing for-schema, and this +explicitly folding version of fac is: + +: +: +(cid:8)(cid:10)(cid:2) : +(cid:1)(cid:3)(cid:2) : +(cid:1)(cid:7)(cid:6) : +: +(cid:1) : + +schema: Functional C +fac +1 +n +int +int +mul +1 +1 +n + +fac +1 +n +int +int +* +1 +1 +n + +: + +: + +This yields the following C implementation below, where mul( accu, i ) has +been simpli(cid:2)ed to accu * i: +int fac( int n ) { + +int i ; +int accu = 1 ; +for( i = 1; i <= n; i++ ) { + +accu = accu * i ; + +} +return accu ; + +} + +To investigate the behaviour of the for-statement, the execution of fac(3) will be +traced. At Step 1 the argument n is allocated, and the variable is associated with +the value 3. + +Revision: 6.41 + +(cid:1) +(cid:15) +(cid:0) +(cid:0) +(cid:13) +(cid:12) +(cid:15) + 84 + +Chapter3. Loops + +n : 3 + +(Step 1) + +int fac( int n ) { + +int i ; +int accu = 1 ; +for( i = 1; i <= n; i++ ) { + +accu = accu * i ; + +} +return accu ; + +} + +At Steps 2 and 3 the local variables i and accu are allocated. The value associ- +ated with i variable is unde(cid:2)ned. This is indicated by the symbol (cid:0) +. The value +associated with accu is 1. +int fac( int n ) { + +int i ; +int accu = 1 ; +for( i = 1; i <= n; i++ ) { + +accu = accu * i ; + +n : 3 +i : (cid:0) +accu : 1 + +(Step 3) + +} +return accu ; + +} + +At Step 4 two actions take place. Firstly, the value 1 will be associated with the +local variable i. This is the initialisation step of the for-statement. Secondly, a test +will be made to see of the current values of i and n satisfy the condition i <= n. +In the present case, the condition yields true. + +int fac( int n ) { + +int i ; +int accu = 1 ; +for( i = 1; i <= n; i++ ) { + +accu = accu * i ; + +} +return accu ; + +} + +n : 3 +i : 1 +accu : 1 + +(Step 4) + +At Step 5 control is transferred to the body of the for-statement. The assignment +statement in the body updates the value associated with the variable accu. As +this cannot be seen in the rendering of the store. At step 6 the control + +variable is incremented to 2. + +Revision: 6.41 + +(cid:0) +(cid:0) +(cid:0) +(cid:0) +(cid:5) +(cid:0) +(cid:0) +(cid:0) + 3.4. Forloops + +85 + +int fac( int n ) { + +int i ; +int accu = 1 ; +for( i = 1; i <= n; i++ ) { + +accu = accu * i ; + +} +return accu ; + +} + +n : 3 +i : 2 +accu : 1 + +(Step 6) + +At Step 7 control is transferred back to the beginning of the for-statement. The +initialisation is not re-executed, but the test i <= n is re-evaluated. It yields true +again. + +int fac( int n ) { + +int i ; +int accu = 1 ; +for( i = 1; i <= n; i++ ) { + +accu = accu * i ; + +(Step 7) + +} +return accu ; + +} + +At Step 8 the body of the for-statement is re-executed, so that the value associated +with accu is updated. At Step 9 the value associated with the control variable is +incremented to 3 and at Step 10 control is transferred back to the beginning of the +for-statement. The condition yields true again. + +int fac( int n ) { + +int i ; +int accu = 1 ; +for( i = 1; i <= n; i++ ) { + +accu = accu * i ; + +} +return accu ; + +} + +n : 3 +i : 3 +accu : 2 + +(Step 10) + +Steps 11, 12 and 13 make another round though the for-loop, producing the state +below. Control has been transferred back to the beginning of the for-statement for +the last time. This time the condition yields false. The for-statement has termi- +nated. + +Revision: 6.41 + +(cid:0) +(cid:0) +(cid:0) + 86 + +Chapter3. Loops + +int fac( int n ) { + +int i ; +int accu = 1 ; +for( i = 1; i <= n; i++ ) { + +accu = accu * i ; + +} +return accu ; + +} + +n : 3 +i : 4 +accu : 6 + +(Step 13) + +At Step 14 the (cid:2)nal value associated with accu is returned. + +int fac( int n ) { + +int i ; +int accu = 1 ; +for( i = 1; i <= n; i++ ) { + +accu = accu * i ; + +} +return accu ; + +} + +return 6 + +(Step 14) + +This concludes the study of the behaviour of the for-statement using the optimised +factorial function. As expected, the amount of space that is used during the exe- +cution is constant, which is the reason why this version is more ef(cid:2)cient than the +recursive version. + +The increasing and decreasing for-schemas form another useful technique that +will help to build ef(cid:2)cient and idiomatic C implementations for commonly occur- +ring patterns of computation. + +3.4.2 Folding from the right + +The for-schemas of Section 3.4 are based on the use of foldl. This is one of two +common folding functions: foldl folds from the left. Its dual foldr folds from +the right. + +(* foldr : ((cid:146)a->(cid:146)b->(cid:146)b) +fun foldr f r [] + += r +| foldr f r (x::xs) = f x (foldr f r xs) ; + +-> (cid:146)b -> (cid:146)a list -> (cid:146)b *) + +The difference between foldl and foldr can be visualised as shown below. Here +we are using a three element list for convenience. The binary folding operator is (cid:0) + +Revision: 6.41 + +(cid:0) +(cid:0) + 3.4. Forloops + +87 + +and the starting value for the folding process is (cid:1) . + +foldl (cid:0) + +(cid:8)(cid:10)(cid:2) + +by contrast + +foldr (cid:0) + +(cid:1)(cid:0)(cid:3)(cid:2) + +(cid:1)(cid:0)(cid:3)(cid:2) + +Folding from the right by foldr gives rise to a second set of two for-schemas: +(*SML foldr schema*) +(* (cid:0) : (cid:1)(cid:3)(cid:2) -> ... -> (cid:1) +fun (cid:0)(cid:9)(cid:8)(cid:10)(cid:2) ... (cid:8) += foldr (cid:13) + +(cid:1) -> (cid:1)(cid:7)(cid:6) *) + +) ; + +(cid:1) ( + +-- + +(cid:2)(cid:17)(cid:16)(cid:18)(cid:16)(cid:18)(cid:16)(cid:19)(cid:8) + +(cid:1) are variables of types (cid:1) + +As before, the (cid:8) +represents a function of type int -> (cid:1)(cid:22)(cid:6) -> (cid:1)(cid:7)(cid:6) , the (cid:1) + +is an expression that +and +(cid:1) may occur in the expressions +. The function name (cid:0) should not occur on the right hand side of the + +are expressions of type int. The variables (cid:8) +, (cid:1) , +, and +equals sign. + +is of type (cid:1)(cid:19)(cid:6) , and the + +(cid:1) . The (cid:13) + +(cid:2)(cid:17)(cid:16)(cid:18)(cid:16)(cid:18)(cid:16)(cid:19)(cid:1) + +(cid:2)(cid:23)(cid:16)(cid:21)(cid:16)(cid:18)(cid:16)(cid:3)(cid:8) + +Again, there are two cases depending on the ordering of + +. Consider the +. The C implementation of the foldr-schema now starts from the + +and + +case that +right and increases the index (cid:0) : +/*C increasing right folding for schema*/ + +(cid:2) , ... (cid:1) + +(cid:1) ) { + +(cid:0) ( (cid:1) +int (cid:0) ; +(cid:1)(cid:5)(cid:6)(cid:1)(cid:0) = (cid:1) ; +for( (cid:0) = + +; (cid:0) <= + +; (cid:0) ++ ) { + +(cid:0) = (cid:13) ( (cid:0) , (cid:0) ) ; + +} +return (cid:0) ; + +} + +The differences between the increasing left and right folding versions of the for- +statement are: + +(cid:1) The roles of + +and + +are swapped + +(cid:1) The arguments of the accumulating function (cid:13) are swapped. + +In the case that +, changes have to be made similar to those discussed in the +previous section for the left folding for-statement. In total, there are four differ- +ent cases of folding, each with its own C for-statement. The key elements are the +following: + +Revision: 6.41 + +(cid:1) +(cid:1) +(cid:8) +(cid:2) +(cid:0) +(cid:0) +(cid:1) +(cid:8) +(cid:0) +(cid:0) +(cid:0) +(cid:1) +(cid:8) +(cid:5) +(cid:0) +(cid:0) +(cid:8) +(cid:8) +(cid:8) +(cid:0) +(cid:0) +(cid:0) +(cid:0) +(cid:0) +(cid:0) +(cid:1) +(cid:1) +(cid:1) +(cid:1) +(cid:0) +(cid:8) +(cid:0) +(cid:8) +(cid:0) +(cid:8) +(cid:0) +(cid:8) +(cid:5) +(cid:8) +(cid:1) +(cid:1) +(cid:2) +(cid:2) +(cid:0) +(cid:0) +(cid:1) +(cid:2) +(cid:0) +(cid:0) +(cid:0) +(cid:1) +(cid:2) +(cid:5) +(cid:0) +(cid:0) +(cid:8) +(cid:8) +(cid:8) +(cid:0) +(cid:0) +(cid:0) +(cid:0) +(cid:0) +(cid:0) +(cid:0) +(cid:0) +(cid:1) +(cid:2) +(cid:2) +(cid:0) +(cid:1) +(cid:2) +(cid:0) +(cid:0) +(cid:1) +(cid:2) +(cid:5) +(cid:0) +(cid:1) +(cid:8) +(cid:8) +(cid:8) +(cid:1) +(cid:12) +(cid:15) +(cid:12) +(cid:15) +(cid:13) +(cid:12) +(cid:15) +(cid:12) +(cid:15) +(cid:12) +, +(cid:15) +(cid:1) +(cid:6) +(cid:2) +(cid:8) +(cid:1) +(cid:8) +(cid:15) +(cid:12) +(cid:12) +(cid:15) +(cid:15) +, +(cid:12) + 88 + +Chapter3. Loops + +(cid:12)-, + +from +to +from +to + +foldr (cid:13) +for( (cid:0) = +foldl (cid:13) +for( (cid:0) = + +(cid:1) ( + +(cid:1) ( + +-- +; (cid:0) >= +-- +; (cid:0) <= + +foldr (cid:13) + +) +; (cid:0) --) for( (cid:0) = +) +; (cid:0) ++) for( (cid:0) = + +foldl (cid:13) + +(cid:1) ( + +(cid:1) ( + +-- +; (cid:0) <= +-- +; (cid:0) >= + +) +; (cid:0) ++) +) +; (cid:0) --) + +The differences between the four versions of the for-schema may seem small, but +they are signi(cid:2)cant. Programming errors caused by the use of an incorrect for- +statement are usually dif(cid:2)cult to (cid:2)nd. Errors, such as the inadvertent swapping +of the upper and lower bounds, cannot be detected by the compiler, since both +bounds will have the same type. Painstaking debugging is the only way to track +down such errors. The four schemas that we have presented provide guidance +in the selection of the appropriate for-statement and should help to avoid many +programming errors. + +Exercise 3.12 In the previous chapter we introduced the function repeat to cap- +ture the common behaviour of the operators (cid:11) +In this chapter +we are using a different capture of the common behaviour, using foldr, +foldl and the -- operator. Can you think of a good reason for this? + +and (cid:10) + +. + +3.5 Generalizing loops and control structures + +The schemas presented so far show how we can transform SML programs system- +atically into equivalent C programs. In this chapter, the schemas transform recur- +sion into loops, thus eliminating a source of inef(cid:2)ciency. The use of the schemas +that we have presented so far has two disadvantages that we will address in this +section. + +The (cid:2)rst disadvantage is that the for-schemas of Sections 3.4 and 3.4.2 are re- +stricted because they deal with a single arithmetic sequence only. We will alleviate +this restriction by allowing more general expressions in the place of the arithmetic +sequence. + +The second disadvantage is that, when larger programs are implemented using +the for-schemas of Sections 3.4 and 3.4.2, the resulting C code is not particularly +idiomatic because all the functions that result from the schemas are smaller than +the functions that are typically found in C programs. The reason for this is that +where in the functional paradigm one uses a number of functions to describe a +certain behaviour, in C one often writes a larger function using using a number of +loops and if-statements. The iterative functions that we have created so far contain +at most one loop. In this section, we will show how to create larger C functions. + +As a (cid:2)rst example program, we will show the development of a function that +computes the sum of the squares of the numbers (cid:0) , (cid:6) , . . . . As a second, more in- +volved example, we develop a function to decide whether a number is perfect. As +a (cid:2)nal example, we compute a table of powers and add all the elements of the ta- +ble. + +Revision: 6.41 + +(cid:12) +(cid:10) +(cid:15) +(cid:15) +(cid:15) +(cid:12) +(cid:15) +(cid:12) +(cid:15) +(cid:12) +(cid:15) +(cid:12) +(cid:15) +(cid:12) +(cid:12) +(cid:12) +(cid:15) +(cid:12) +(cid:15) +(cid:15) +(cid:12) +(cid:15) +(cid:12) +(cid:15) + 3.5. Generalizingloopsandcontrolstructures + +89 + +3.5.1 Combining foldl with map: sum of squares + +Given a positive natural number +squares from (cid:0)(cid:25)(cid:16)(cid:18)(cid:16)(cid:18)(cid:16) + +: + +, consider the problem of summing all the + +sum of squares + +(cid:1)1(cid:15)3(cid:8) + +sum of squares + +(cid:8)(cid:5)(cid:9) + +The SML solution can be written on the basis of the following observations: + +1. Generate all numbers (cid:0) + +(cid:16)(cid:21)(cid:16)(cid:18)(cid:16) + +. + +This requires an arithmetic sequence + +(1 -- n). + +2. Square each number. This is conveniently done by mapping a function +square over all elements of the arithmetic sequence using the standard +function map. + +3. Sum the squares. For this, we use the standard function sum. + +Here is the auxiliary function square: +(* square : int -> int *) +fun square x = x * x : int ; + +For ease of reference, we give the de(cid:2)nitions of the standard functions map and +sum and an auxiliary function add, which is the curried version of the addition +operator +: + +(* sum : int list -> int *) +fun sum xs = foldl add 0 xs ; + +(* add : int -> int -> int *) +fun add x y = x + y : int ; + +(* map : ((cid:146)a->(cid:146)b) +fun map h [] + +-> (cid:146)a list -> (cid:146)b list *) += [] +| map h (x::xs) = h x :: map h xs ; + +With these preparations, the SML version of sum_of_squares can now be writ- +ten as follows: + +(* sum_of_squares : int -> int *) +fun sum_of_squares n + += sum (map square (1 -- n)) ; + +To derive a C implementation of sum_of_squares, we need to be able to match +In its present form, sum_of_squares +its SML de(cid:2)nition to the foldl-schema. +does not match the foldl-schema because of the absence of a call to foldl and +the presence of the call to map. The (cid:2)rst problem is easy to solve by substituting +the de(cid:2)nition of sum. This exposes the foldl: +(* sum_of_squares : int -> int *) +fun sum_of_squares n + += foldl add 0 (map square (1 -- n)) ; + +Revision: 6.41 + +(cid:15) +(cid:15) +(cid:0) +(cid:2) +(cid:4) +(cid:10) +(cid:2) +(cid:4) +(cid:0) +(cid:4) +(cid:0) +(cid:2) +(cid:0) +(cid:0) +(cid:15) + 90 + +Chapter3. Loops + +The second problem is solved by using one of the standard equations that relate +foldl and map. It has a more general form than we need right now, but it is often +a good idea to try to state and prove as general a result as possible. When given a +function (cid:14) such that: + +fun (cid:14) + +(cid:1) ( (cid:0) + +(cid:8) ) + +Then the following equation is true for all (cid:2)nite lists (cid:8) + +(cid:3) and all (cid:0) + +, (cid:13) and (cid:1) : + +foldl (cid:13) + +(cid:1) (map (cid:0)(cid:9)(cid:8) + +(cid:3) ) (cid:0) + +foldl (cid:14) + +(3.4) + +Exercise (cid:0) 3.13 Prove (3.4) by induction on the length of the list (cid:8) + +(cid:3) . + +. Let +To make use of the equation (3.4), we need to identify the functions (cid:0) +us put the essential ingredients in a table of correspondence so that it is possible to +see the relationships: + +, (cid:13) and (cid:14) + +equation (3.4) + +fun (cid:14) + +(cid:8) = (cid:13) + +sum_of_squares +square +add +add_square +(cid:1) ( (cid:0)(cid:9)(cid:8) ) fun add_square b x + += add b (square x) + +The net result of using the correspondences of the table above is: + +(* add_square : int -> int -> int *) +fun add_square b x = add b (square x) ; + +(* sum_of_squares : int -> int *) +fun sum_of_squares n + += foldl add_square 0 (1 -- n) ; + +This last version of sum_of_squares is implemented in C using the left folding +increasing for schema: + +int add( int x, int y ) { + +return x + y ; + +} + +int square( int x ) { + +return x * x ; + +} + +int add_square( int b, int x ) { +return add( b, square( x ) ) ; + +} + +int sum_of_squares( int n ) { + +int i ; + +Revision: 6.41 + +(cid:1) +(cid:8) +(cid:0) +(cid:13) +(cid:1) +(cid:8) +(cid:3) +(cid:0) +(cid:13) +(cid:14) +(cid:1) + 3.5. Generalizingloopsandcontrolstructures + +91 + +int accu = 0 ; +for( i = 1; i <= n; i++ ) { + +accu = add_square( accu , i ) ; + +} +return accu ; + +} + +As a (cid:2)nishing touch, we can inline the body of add and square in that of +add_square and then inline the body of add_square in sum_of_squares. In +this case, the inlining is straightforward as the C functions add, square, and +add_square all contain just a return-statement. Here is the result of the inlining: + +int sum_of_squares( int n ) { + +int i ; +int accu = 0 ; +for( i = 1; i <= n-1; i++ ) { + +accu = accu + (i * i) ; + +} +return accu ; + +} + +This shows that we have achieved the two goals. Firstly, we have a way of dealing +with an expression that is not just a left folding over an arithmetic sequence, so +we have generalised the for-schema. Secondly, we have created a slightly larger C +function than we have been able to do so far. + +3.5.2 Combining foldl with filter: perfect numbers + +is a perfect number if it is equal to the sum of those + +A positive natural number +factors that are strictly less than + +itself. Examples of perfect numbers are 6 ( (cid:0) +(cid:1) ). The problem that we are about to solve is to +write a function that determines whether its argument is a perfect number. Here +is the speci(cid:2)cation that a perfect number + +has to satisfy: + +) and 28 ( (cid:0) + +perfect + +(cid:1)1(cid:15)3(cid:8) + +perfect + +(cid:15)(cid:7)(cid:29) + +(cid:18)! #" + +&% + +(3.5) + +Let us develop the solution by top-down program design: Assume that we already +have a function sum_of_factors to compute the sum of those factors of a num- +ber that are strictly less than the number itself. Then, the (cid:2)rst part of the solution +is: + +(* perfect : int -> bool *) +fun perfect n = n = sum_of_factors n ; + +The second problem is to compute the sum of the factors. This problem has three +parts, each corresponding to the three important elements of the problem speci(cid:2)- +cation (3.5): + +1. Generate all potential factors of n which are strictly less than n. This requires + +an arithmetic sequence (1 -- n-1). + +Revision: 6.41 + +(cid:15) +(cid:15) +(cid:0) +(cid:2) +(cid:6) +(cid:2) +(cid:2) +(cid:0) +(cid:2) +(cid:6) +(cid:2) +(cid:1) +(cid:2) +(cid:6) +(cid:2) +(cid:0) +(cid:15) +(cid:0) +(cid:2) +(cid:4) +(cid:10) +(cid:2) +(cid:0) +(cid:0) +(cid:15) +(cid:0) +(cid:0) +(cid:23) +(cid:0) +(cid:11) +(cid:0) +(cid:10) +(cid:15) +(cid:0) +(cid:0) +* + 92 + +Chapter3. Loops + +2. Remove all numbers i from the list of potential factors that do not satisfy +the test n mod i = 0, as such i are relatively prime with respect to n. The +standard filter function removes each element for which rel_prime re- +turns true. + +3. All remaining elements of the list are now proper factors, which can be + +summed using the standard function sum. + +The results of the problem analysis give rise to the following program: + +(* rel_prime : int -> int -> bool *) +fun rel_prime n i = n mod i = 0 ; + +(* sum_of_factors : int -> int *) +fun sum_of_factors n + += sum (filter (rel_prime n) (1 -- n-1)) ; + +For ease of reference, here is the de(cid:2)nition of the standard function filter: + +(* filter : ((cid:146)a->bool) -> (cid:146)a list -> (cid:146)a list *) += [] +fun filter p [] + +| filter p (x::xs) = if p x + +then x :: filter p xs +else filter p xs ; + +As in the previous section, to derive a C implementation of sum_of_factors we +need to be able to match its SML de(cid:2)nition to the foldl-schema. Substituting the +de(cid:2)nition of sum exposes the foldl: + +(* sum_of_factors : int -> int *) +fun sum_of_factors n + += foldl add 0 (filter (rel_prime n) (1 -- n-1)) ; +To remove the filter we use an equation relating foldl and filter. This +equation is similar tho that used to remove the map earlier. When given a func- +tion (cid:14) such that: + +fun (cid:14) + +if (cid:12) + +(cid:8) then (cid:13) + +(cid:8) else (cid:1) + +Then the following equation holds for all (cid:2)nite lists (cid:8) + +(cid:3) and all (cid:12) + +, (cid:13) + +, and (cid:1) : + +foldl (cid:13) + +(cid:1) (filter (cid:12) + +(cid:3) ) (cid:0) + +foldl (cid:14) + +(3.6) + +Exercise (cid:0) 3.14 Prove (3.6) by induction on the length of the list (cid:8) + +(cid:3) . + +To use (3.6) requires us to identify the predicate (cid:12) and the functions (cid:13) +equation. Here is the table of correspondences: + +, and (cid:14) of the + +equation (3.6) sum_of_factors + +fun (cid:14) + +(rel_prime n) +add +add_rel_prime n +fun add_rel_prime n b x + += if (rel_prime n) x + +then add b x +else b + +Revision: 6.41 + +(cid:1) +(cid:8) +(cid:0) +(cid:1) +(cid:8) +(cid:1) +(cid:8) +(cid:3) +(cid:12) +(cid:13) +(cid:14) +(cid:1) +(cid:8) + 3.5. Generalizingloops andcontrolstructures + +93 + +The de(cid:2)nition of add_rel_prime above is quite interesting. The role of the +is played by the partial application (rel_prime p). Now we +schematic variable (cid:12) +should ask ourselves the question: where does the n come from? If we were to try +the following de(cid:2)nition, the SML compiler would complain about the variable n +being unde(cid:2)ned: + +(* add_rel_prime : int -> int -> int *) +fun add_rel_prime b x + += if (rel_prime n) x + +then add b x +else b ; + +The solution to this problem is to make n an extra argument of add_rel_prime, +as we have shown in the table of correspondence above. + +We are now able to write a new version of sum_of_factors consisting of an + +arithmetic sequence and a call to foldl: + +(* add_rel_prime : int -> int -> int -> int *) +fun add_rel_prime n b x + += if (rel_prime n) x + +then add b x +else b ; + +(* sum_of_factors : int -> int *) +fun sum_of_factors n + += foldl (add_rel_prime n) 0 (1 -- n-1) ; + +The extra argument n to add_rel_prime is now passed explicitly by the partially +applied call (add_rel_prime n). The latest version of sum_of_factors con- +forms to the foldl-schema and can be translated directly into C: + +bool rel_prime( int n, int i ) { + +return n % i == 0 ; + +} + +int add_rel_prime( int n, int b, int x ) { + +if( rel_prime( n, x ) ) { +return add( b, x ) ; + +} else { + +return b ; + +} + +} + +int sum_of_factors( int n ) { + +int i ; +int accu = 0 ; +for( i = 1; i <= n-1; i++ ) { + +accu = add_rel_prime( n, accu, i ) ; + +} +return accu ; + +Revision: 6.41 + + 94 + +} + +Chapter3. Loops + +bool perfect( int n ) { + +return sum_of_factors( n ) == n ; + +} + +As a (cid:2)nishing touch, we substitute the bodies of the functions rel_prime, add, +add_rel_prime, and sum_of_factors in perfect. This is not completely +trivial, inlining add_rel_prime in the function sum_of_factors requires us +to replace both return statements with assignments to accu. This results in the +following function: + +int sum_of_factors( int n ) { + +int i ; +int accu = 0 ; +for( i = 1; i <= n-1; i++ ) { +if( rel_prime( n, i ) ) { +accu = add( accu, i ) ; + +} else { + +accu = accu ; + +} + +} +return accu ; + +} + +The else branch of the if statement is not useful (it states that accu should +not be modi(cid:2)ed), so this branch can be removed safely. The functions add and +rel_prime can also be inlined, and the whole function can then be inlined in +perfect, resulting in the compact C function below. The function contains a for +loop and a conditional, and is thus slightly larger than the functions delivered by +a straight application of a for schema. + +bool perfect( int n ) { + +int i ; +int accu = 0 ; +for( i = 1; i <= n-1; i++ ) { + +if( n % i == 0 ) { + +accu = accu + i ; + +} + +} +return accu == n ; + +} + +We have come a long way in this process, for we have derived this function in a +systematic way. We could have made a short-cut by using a separate schema that +recognises the combination of foldl and filter explicitly. The if-statement then +ensures that the body of the for-loop is only executed for those values of i where +rel_prime succeeds. This is what one would guess intuitively. The interesting +point of the above reasoning is that it can be applied to the general case. Without +de(cid:2)ning any more schema’s, for-loops, while-loops, if-statements, and functions + +Revision: 6.41 + + 3.5. Generalizingloops andcontrolstructures + +95 + +can be combined. + +The substitution of C functions as shown above is not always valid. This is +only safe where pure functions are considered. Functions that rely on side effects, +which will be shown in Chapters 4 and 5, do not always allow for safe substitu- +tion. + +3.5.3 Nested for statements + +Nested recursion, that is, recursion within recursion, is common. It is worthwhile +to investigate whether the for-schema can be applied to deal with this. Consider +the following problem. Given two natural numbers +, generate a table of +the powers +(cid:9) , this +yields the following table: + +(cid:0) of all numbers from % + +and +. For + +(cid:1) and + +and % + +(cid:16)(cid:21)(cid:16)(cid:18)(cid:16) + +(cid:16)(cid:21)(cid:16)(cid:18)(cid:16) + +0 1 +1 0 +1 1 +1 2 +1 3 +1 4 + +2 +0 +1 +4 +9 +16 + +4 +3 +0 +0 +1 +1 +16 +8 +27 +81 +64 256 + +5 +0 +1 +32 +243 +1024 + +0 +1 +2 +3 +4 + +We want to compute the sum of all these powers, 1799 in the case of the above +table. In general, the sum is: + +sum of sum of powers + +(cid:1)(cid:13)(cid:15)(cid:17)(cid:8) + +sum of sum of powers + +(cid:8)(cid:5)(cid:9) + +(3.7) + +This shows a summation within a summation. It is not dif(cid:2)cult to (cid:2)nd a formula +that computes the same answer using a single summation, but to (cid:2)nd one that +uses no summation at all is more dif(cid:2)cult. To show how nested for-statements +may be created, we will perform the double summation here. + +The + +innermost +summation of (3.7) is easily written as a function sum_of_powers. It will have +two arguments, m and i: + +(* sum_of_powers : int -> int -> int *) +fun sum_of_powers m i + += sum (map (power i) (0--m)) ; + +An integer version of the power function from Section 2.4 can be used here to +do the actual exponentiation. The technique for dealing with a combination of +map and foldl of Section 3.5.2 gives us the following C implementation of +sum_of_powers: + +int sum_of_powers( int m, int i ) { + +int k ; +int accu = 0 ; + +Revision: 6.41 + +(cid:15) +(cid:12) +(cid:15) +(cid:15) +(cid:12) +(cid:15) +(cid:0) +(cid:12) +(cid:0) +(cid:0) +(cid:10) +(cid:12) +(cid:0) +(cid:1) +(cid:0) +(cid:0) +(cid:15) +(cid:0) +(cid:2) +(cid:4) +(cid:10) +(cid:2) +(cid:4) +(cid:0) +(cid:4) +(cid:0) +(cid:1) +(cid:1) +(cid:0) +(cid:0) +(cid:1) +(cid:9) +(cid:1) +(cid:0) +(cid:1) +(cid:8) + 96 + +} + +for( k = 0; k <= m; k++ ) { + +accu = accu + power( i, k ) ; + +} +return accu ; + +Chapter3. Loops + +The outermost summation of (3.7) also translates directly into the function +sum_of_sum_of_powers below. This function also has two arguments, m and +n. + +(* sum_of_sum_of_powers : int -> int -> int *) +fun sum_of_sum_of_powers m n + += sum (map (sum_of_powers m) (0--n)) ; + +Here we have again a combination of map and foldl, so that we can create the +following C implementation: + +int sum_of_sum_of_powers( int m, int n ) { + +int i ; +int accu = 0 ; +for( i = 0; i <= n; i++ ) { + +accu = accu + sum_of_powers( m, i ) ; + +} +return accu ; + +} + +The combined result of our efforts is to create two functions that together solve +the problem. However, the conciseness of the mathematical speci(cid:2)cation of (3.7) +is lost, even in the SML solution. C permits us to recover some of the com- +pactness of the speci(cid:2)cation by substituting the body of sum_of_powers into +sum_of_sum_of_powers. The result is an idiomatic C function with a nested +for-statement: + +int sum_of_sum_of_powers( int m, int n ) { + +int i,k ; +int accu = 0 ; +for( i = 0; i <= n; i++ ) { + +for( k = 0; k <= m; k++ ) { + +accu = accu + power( i, k ) ; + +} + +} +return accu ; + +} + +3.6 Summary + +The following C constructs were introduced: + +Revision: 6.41 + + 3.6. Summary + +97 + +Assignments In C values associated with variables can be changed. The assign- + +ment has the general form: + +(cid:8) = (cid:0) + +is a variable and (cid:0) + +Here (cid:8) +is an expression; (cid:8) and (cid:0) must be of the same type. +Usually, the assignment is used as a statement, for example i=i+1;. How- +ever, an assignment is in itself an expression, the value on the right hand +side being the value of the expression. It is allowed to write: b=c=0 which +assigns 0 to both b and c. Using an assignment in an expression does not +often improve the clarity of the program. + +In addition to the ordinary assignment above, there is a family of assignment +operators, +=, -=, *=, and so on. These operators perform a computation +and then write the result back into the variable on the left hand side. For +example i+=1 is identical to i=i+1. Finally, there are some shortcuts, ++i +and --i are abbreviations for i=i+1 and i=i-1. + +While-loops The while loop executes statements repeatedly, until the while con- + +dition becomes false. The general form of the while loop is: + +while( (cid:12) ) { + +} + +The statements (cid:0) are executed for as long as the condition (cid:12) does not evalu- +ate to 0. + +For-loops The for loop executes statements repeatedly, until the for condition be- + +comes false. The general form of the for loop is: +) { + +; (cid:12) ; + +for( + +} + +is executed, to initialise. While the condition (cid:12) eval- +Before the loop starts, +uates to true, the statements (cid:0) +are executed. The +most frequently used forms of these loops are the incrementing and decre- +menting for loop: + +followed by the iteration + +for( (cid:0) =0 ; (cid:0) < + +; (cid:0) ++ ) { + +for( (cid:0) = + +-1 ; (cid:0) >=0 ; (cid:0) -- ) { + +} + +} + +Here (cid:0) stands for any integer variable, and +loop is to be executed. + +is the number of times that the + +Breaking out of a loop The statement break; will cause the execution of a loop +to be terminated immediately. Execution resumes after the closing curly +bracket of the loop body. + +Revision: 6.41 + +(cid:0) +(cid:2) +(cid:4) +(cid:0) +(cid:2) +(cid:4) +(cid:15) +(cid:0) +(cid:15) +(cid:0) +(cid:15) + 98 + +Chapter3. Loops + +From a programming principles point of view, the most important issues that we +have addressed are the following: + +(cid:1) A good understanding of the behaviour of the store is essential before ef(cid:2)- +cient C functions can be implemented. Local variables can be reused (de- +stroying the old values). Local variables can only be used within the func- +tion in which they are declared. They exist as long as the function invocation +exists. + +(cid:1) Side effects should be visible, and they should be localised. A function may +internally use side effects to increase ef(cid:2)ciency; however, externally it should +not be distinguishable from functions that do not use side effects. + +(cid:1) Functions should have clear and concise interfaces. That is, if the same func- +tionality can be obtained using fewer arguments, then this is to be preferred. + +(cid:1) The C programmer has to make sure that values are computed and assigned +to variables before they are used. It is good programming practice to always +initialise local variables. + +(cid:1) Tail recursive functions are preferred over non-tail recursive functions since +the former can ef(cid:2)ciently be implemented as loops. Non-tail recursive func- +tions can often be transformed into tail recursive functions by expedient use +of ad-hoc transformations, such as the accumulating argument technique. + +3.7 Further exercises + +Exercise 3.15 The function sum_of_sum_of_powers is rather inef(cid:2)cient if it +uses a naive power function, that is one that performs (cid:0) multiplications +. Rewrite sum_of_sum_of_powers such that it completely +to compute (cid:0) +avoids the use of a power function, and thus makes the least possible num- +ber of multiplications. + +Exercise 3.16 Exercise 2.21 required the implementation of a pop_count func- + +tion. Implement this function in C with a loop. + +Exercise 3.17 Exercise 2.25 required the implementation of a power_of_power +function. Reimplement the C function using loops. Try to embed the func- +tions into each other so that you don’t have an auxiliary function power. + +Exercise 3.18 Write a C function chess_board with two integer arguments +height chess board using ASCII +the output should look as fol- + +width and height to print out a width +(cid:1) and height (cid:0) +characters. If width (cid:0) +lows: + +--------- +| |X| |X| +--------- +|X| |X| | +--------- + +Revision: 6.41 + +(cid:1) +(cid:5) +(cid:6) + 3.7. Furtherexercises + +99 + +Exercise 3.19 Using a loop, write a function that determines the root of a continu- +ous function using the Newton-Raphson method. Use the answer of Exer- +cise 2.26 as the starting point. + +Revision: 6.41 + + 100 + +Chapter3. Loops + +Revision: 6.41 + + c(cid:0) + +1995,1996 Pieter Hartel & Henk Muller, all rights reserved. + +Chapter 4 + +Structs and Unions + +The functions discussed so far operate on either integers, booleans, characters, +(cid:3)oating point numbers, or functions. These are all primitive types in C (with re- +strictions) and in SML (without restrictions). Like SML, C has support for struc- +tured data. In its simplest form, structured data makes it possible to gather into +one object a collection of previously de(cid:2)ned values of particular types. This builds +a structured data type from a collection of previously de(cid:2)ned types. This is, for +example, supported with the tuple of SML and with the struct of C. These so- +called ‘(cid:3)atly structured aggregate data types’ are the subject of this chapter. +In +subsequent chapters we will look at other forms of structured data, namely se- +quences of data items (arrays, Chapter 5) and recursively structured data types +(lists, Chapter 6). + +4.1 Structs + +The primitive data structures discussed in the previous chapter make it possible +to pass single numbers around. Often, one is not interested in single numbers +but in a collection of numbers. An example of a collection of numbers is a point +in a plane, say (cid:12) +is the X- +coordinate and (cid:12) +is the Y-coordinate. An operation that one may wish to perform +on a point is to rotate it around the origin. To rotate a point (cid:12) +around +the origin by 90 degrees in the clockwise direction, we compute a new point, say +(cid:0) : +(cid:0) , with coordinates (cid:0) + +. The point is represented by a tuple + +, where (cid:12) + +(cid:0) and (cid:0) + +(cid:1)(cid:3)(cid:2) + +(cid:5)(cid:7)(cid:2) + +Here is the type point in SML: + +type point = real * real ; + +The SML rotation function takes a point and computes the rotated point as +shown below. For the name of this function, we would have liked to use ‘new- +point-which-is-the-old-one-rotated’. This would express our intentions clearly. + +101 + +(cid:1) +(cid:12) +(cid:0) +(cid:14) +(cid:12) +(cid:0) +(cid:8) +(cid:0) +(cid:0) +(cid:0) +(cid:1) +(cid:12) +(cid:0) +(cid:14) +(cid:12) +(cid:0) +(cid:8) +(cid:0) +(cid:0) +(cid:12) +(cid:0) +(cid:0) +(cid:0) +(cid:12) +(cid:12) +(cid:14) +(cid:0) +(cid:0) +(cid:6) +(cid:6) +(cid:8) +(cid:1) +(cid:0) +(cid:0) +(cid:14) +(cid:0) +(cid:0) +(cid:8) +(cid:0) +(cid:1) +(cid:12) +(cid:0) +(cid:14) +(cid:0) +(cid:12) +(cid:0) +(cid:8) + 102 + +Chapter4. StructsandUnions + +However, a long name like that is not practical, so we will use the rather conven- +tional rotate. + +(* rotate : point -> point *) +fun rotate (p_x,p_y) = (p_y,0.0-p_x) ; + +The following equalities are all true: + +rotate ( 1.0, 0.0) = ( 0.0,˜1.0) ; +rotate (˜0.1,˜0.3) = (˜0.3, 0.1) ; +rotate ( 0.7,˜0.7) = (˜0.7,˜0.7) ; + +These three rotations are shown graphically in the (cid:2)gure below: + ++ + ++ + ++ ++ + ++ + ++ + +C does not offer plain tuples, but it provides a more general mechanism: +struct. The general form of a struct declaration is: + +the + +struct { +(cid:1) ; +(cid:2) ; + +... + +} + +(cid:8) are the types and the + +Here the (cid:1) +(cid:8) are the names of the structure components, +also known as members. A typedef can be used to associate a type name with the +structured type. The declaration of a struct that contains the two coordinates of a +point reads: + +typedef struct { + +double x ; +double y ; + +} point ; + +This declares a struct with two members x and y, and gives it the name point. +The function for rotating a point should be written as follows: + +point rotate( point p ) { + +point r ; +r.x = p.y ; +r.y = -p.x ; +return r ; + +} + +The C function rotate has a single argument of type point. The return value is +also of type point. The body of rotate allocates a local variable r of type point +and makes two separate assignments to the members of r. Members are referred +to using a dot-notation, so p.y refers to the value of the member with name y +in the point-structure p. Therefore, the assignment r.x = p.y means: take the + +Revision: 6.37 + +(cid:1) +(cid:1) +(cid:12) +(cid:1) +(cid:2) +(cid:12) +(cid:12) + 4.1. Structs + +103 + +value of the y member of p and assign this value to the x member of r. The y +member of r is not altered. The second assignment (cid:2)lls the y member of r. Fi- +nally, the value of r is returned. This is different from the SML version of rotate, +which creates its result tuple in a single operation. Unfortunately, C does not have +a general syntax to create a struct, in contrast with most functional languages +that do have syntax to create tuples. + +To print a point, a new function has to be de(cid:2)ned, because printf has no +knowledge how to print structured data. This new function print_point is +shown below: + +void print_point( point p ) { + +printf( "(%f,%f)\n", p.x, p.y ) ; + +} + +The return type of this function is void. This means it will return nothing. This +function would not have a meaning in a pure functional language, as it cannot +do anything. In an imperative language, such functions do have a meaning, as +they can print output as a side effect. Another use of functions with a void type +is shown in Section 4.4, where the different argument passing methods of C are +discussed. Some imperative languages have a special notation for a function that +does not return a value; such a function is called a procedure in Pascal or a subrou- +tine in Fortran. + +The body of print_point consists of a call to printf with three arguments: +the format string and the values of the x and y coordinates of the point. The for- +mat string and the arguments are handled exactly as discussed in Chapter 2. The +parentheses, comma, and the newline character are printed literally, while the %f +parts are replaced with a numerical representation of the second and third argu- +ments. + +The function main shown below declares a local variable r of type point. +Firstly, main assigns r a value corresponding to the point +. It then rotates +. This is followed by +this point and prints the result, producing the output +two similar calls to assign new values to the point r, rotate the point, and print the +result. + +int main( void ) { + +point r ; +r.x = 1 ; r.y = 0 ; +print_point( rotate( r ) ) ; +r.x = -0.1 ; r.y = -0.3 ; +print_point( rotate( r ) ) ; +r.x = 0.7 ; r.y = -0.7 ; +print_point( rotate( r ) ) ; +return 0 ; + +} + +The function main shows again that C does not provide syntax to create a struct +directly. However, there is one exception to this rule. In the declaration of a con- +stant or in the initialisation of a variable, one can create a struct by listing the +values of the components of the struct if all these values are constants. Using + +Revision: 6.37 + +(cid:1) +(cid:0) +(cid:14) +% +(cid:8) +(cid:1) +% +(cid:14) +(cid:0) +(cid:0) +(cid:8) + 104 + +Chapter4. StructsandUnions + +this notation, we may reformulate the main program: + +int main( void ) { + +1, 0 } ; + +const point r0 = { +const point r1 = {-0.1, -0.3 } ; +const point r2 = { 0.7, -0.7 } ; +print_point( rotate( r0 ) ) ; +print_point( rotate( r1 ) ) ; +print_point( rotate( r2 ) ) ; +return 0 ; + +} + +The curly bracket notation for creating a struct is only legal during the initiali- +sation of a constant or a variable. The curly bracket notation is illegal anywhere +else. In particular, it is not permitted to write rotate( {1, 0} ) in the call to +print_point, which would obviate the need for the local constant r0. + +Notice the ordering of the statements of main. The function main starts with +the declaration of three constants r0, r1, and r2. Then these three values are used +in the three successive calls to rotate. C requires all constants and variables to be +declared before the statements. This results in the seemingly out of order creation +of the structs r0, r1, and r2 and calls to rotate. Interestingly, C++ does not have +this constraint. In this language variables and constants can be declared anywhere +in a program, not only at the beginning of a block. + +4.2 Structs in structs + +A struct can be used not only to gather primitive data types into a (cid:3)atly struc- +tured data type, but also to build more complex data structures out of those previ- +ously built. Given that we have available the type point, it is possible to create a +new type rectangle by listing the coordinates of the lower left and upper right +corners of the rectangle. A function that calculates the area of the rectangle would +be: + +(cid:8)(cid:16)(cid:14) + +area + +(cid:1)(cid:0) + +(cid:2)(cid:0) + +(cid:3)(cid:0) + +(cid:3)(cid:0) + +(cid:1).(cid:2) + +(cid:5)(cid:7)(cid:2) + +(cid:8)((cid:5) + +(cid:1)(cid:3)(cid:2) + +(cid:5)(cid:7)(cid:2) + +(cid:8)(cid:11)(cid:10) + +area + +(4.1) + +The SML type rectangle uses point as follows: + +type rectangle = point * point ; + +Using this new data type, the SML function area is: (the function absolute is +de(cid:2)ned in Section 2.5.3): + +(* area : rectangle -> real *) +fun area ((llx,lly),(urx,ury)) + += absolute ((urx-llx) * (ury-lly)) ; + +Revision: 6.37 + +(cid:0) +(cid:1) +(cid:6) +(cid:6) +(cid:6) +(cid:6) +(cid:8) +(cid:2) +(cid:6) +(cid:1) +(cid:1) +(cid:0) +(cid:0) +(cid:0) +(cid:14) +(cid:0) +(cid:0) +(cid:0) +(cid:1) +(cid:0) +(cid:0) +(cid:14) +(cid:0) +(cid:0) +(cid:8) +(cid:8) +(cid:0) +(cid:29) +(cid:1) +(cid:0) +(cid:0) +(cid:0) +(cid:0) +(cid:0) +(cid:0) +(cid:8) +(cid:5) +(cid:1) +(cid:0) +(cid:0) +(cid:0) +(cid:0) +(cid:0) +(cid:0) +(cid:8) +(cid:29) + 4.3. Unionsinstructs:algebraicdatatypes + +105 + +In C, the type of the rectangle is de(cid:2)ned as follows, where we have repeated the +de(cid:2)nition of point for ease of reference: + +typedef struct { + +double x ; +double y ; + +} point ; + +typedef struct { + +point ll ; +point ur ; +} rectangle ; + +/* X-coordinate of point */ +/* Y-coordinate of point */ + +/* Lower Left hand corner */ +/* Upper Right hand corner */ + +The function to calculate the area then becomes: + +double area( rectangle r ) { + +return absolute( ( r.ur.x - r.ll.x ) * + +( r.ur.y - r.ll.y ) ) ; + +} + +The argument r refers to the whole rectangle, r.ll refers to the lower left hand +corner, and r.ll.x refers to the X-coordinate of the lower left hand corner. Simi- +larly, r.ur.x refers to the X-coordinate of the upper right hand corner. + +In this example both point and rectangle were de(cid:2)ned as a new type, using +typedef. It is equally valid only to de(cid:2)ne the type rectangle, and to embed the +structure storing a point in it: + +typedef struct { + +struct { + +double x ; +double y ; + +} ll, ur ; +} rectangle ; + +/* X-coordinate of point */ +/* Y-coordinate of point */ +/* Lower left & Upper right */ + +This does not de(cid:2)ne a type for point, hence points cannot be passed on their own +(because they have no type with which to identify them). In general, one will em- +bed a structure (as opposed to de(cid:2)ning a separate type), when the structure on its +own does not have a sensible meaning. + +4.3 Unions in structs: algebraic data types + +A tuple can be used to store a collection of values, but a tuple does not suggest +how the type is being used in the program. If one has a tuple of two integers, for +example (7,4), then this tuple can encode a date (the 7th of April, or the 4th of +July, depending on the country you are in), but it could also encode a time (7:04 +pm), or a fractional number ( +). Algebraic data types are used instead of tuples +when a particular data type may have different interpretations and/or alternative +forms. For example, the following type can be de(cid:2)ned in SML to encode a distance +in either (cid:9)Angstr¤oms, miles, kilometres, or light years. + +datatype distance = Angstrom of real | + +Revision: 6.37 + +(cid:0) +(cid:3) + 106 + +Chapter4. StructsandUnions + +Mile +of real | +Kilometre of real | +Lightyear of real ; +Using the data type distance we can write a conversion function that takes any +one of the four different possibilities and calculates the distance in millimetres. +Pattern matching is used to select the appropriate de(cid:2)nition of mm: + +(* mm : distance -> real *) +fun mm (Angstrom x) + +| mm (Kilometre x) +| mm (Mile x) +| mm (Lightyear x) + += x * 1E˜7 += x * 1E6 += x * 1.609344E6 += x * 9.4607E21 ; + +Adding distances that are speci(cid:2)ed in different units is now possible, for example: + +mm (Mile 1.0) + mm (Kilometre 4.0) = 5609344.0 ; + +C does not have a direct equivalent of the algebraic data type. Such a type must +be composed using the three data structuring tools enum, struct, and union. +The enum (Section 2.2.6) will enumerate the variants, the struct (Section 4.1) will +hold various parts of the data, the union, de(cid:2)ned below, allows to store variants. + +4.3.1 Union types + +The general form of the union de(cid:2)nition is similar to that of a struct de(cid:2)nition: + +union { + +(cid:1) ; +(cid:2) ; + +... + +} + +(cid:8) are the types and the + +(cid:8) are the names of the members of the union. +Here the (cid:1) +The difference between a struct and a union is that the latter stores just one of +its members at any one time, whereas the former stores all its members at the same +time. A struct is sometimes called a product of types, while a union is a sum +of types. In SML, we have the same distinction: the alternatives in an algebraic +data type declaration (as separated by vertical bars) represent the sum type, and +the types within each alternative represent a product type. + +The storage model can be used to visualise the differences between a struct +and a union. Assume that we have a structure pair which is de(cid:2)ned as follows: + +typedef struct { + +int x ; +int y ; + +} pair ; + +Below are a structure (structx) and a union (unionx), with their respective stor- +age requirements: + +Revision: 6.37 + +(cid:1) +(cid:1) +(cid:12) +(cid:1) +(cid:2) +(cid:12) +(cid:12) + 4.3. Unionsinstructs:algebraicdatatypes + +107 + +typedef struct { + +int i ; +double d ; +pair p ; + +} structtype ; + +typedef union { + +int i ; +double d ; +pair p ; +} uniontype ; + +structtype structx ; + +uniontype unionx ; + +structx: + +i + +d + +p.x + +p.y + +unionx: + +i, d, or p.x + +(cid:0) or p.y + +In the data structure structx, an integer value i, a double precision (cid:3)oating +point number d, and a pair p are stored at the same time. The data structure unionx +either stores an integer i, or a (cid:3)oating point value d, or a pair p at any one time. +The struct is thus larger than the union, as it must reserve space for all its mem- +bers. The union is as large as its largest member, which is the type pair in this +example. + +Exercise 4.1 The example shown above assumes that the member d of the type +double occupies one storage cell. Often, a double occupies two storage +cells. Draw the storage requirements of structx and unionx under the +assumption that the (cid:3)oating point number d is stored in two storage cells. + +The union of C does not provide type security. Suppose that the type uniontype +as de(cid:2)ned earlier is used as follows: + +int abuse_union( double x ) { + +uniontype y ; +y.d = x ; +return y.i ; + +} + +When abuse_union( 3.14 ) is executed, it will (cid:2)rst create a variable y of type +uniontype and write the value 3.14 in the d member of the union. Then the value +of the i member of the union is returned. This is legal C, but logically it is an +improper operation. Probably, the function abuse_union will return part of the +bit pattern of the binary representation of the number 3.14, but the precise value +will depend on the peculiarities of the implementation. + +To use a union properly, the programmer must keep track of the types that +are stored in the unions. Only the type that has been stored in a union should +be retrieved. In general, the programmer has to maintain a tag to specify what is +stored in a union. Because this tag has to be stored together with the union, both +are conveniently embedded in a struct. This recipe results in the following C + +Revision: 6.37 + + 108 + +Chapter4. StructsandUnions + +data type for maintaining a distance: + +typedef enum { Angstrom, Mile, + +Kilometre, Lightyear } distancetype ; + +typedef struct { + +distancetype tag ; +union { + +double angstroms ; +double miles ; +double kilometres ; +double lightyears ; + +} contents ; + +} distance ; + +The possible distance types are enumerated in the type distancetype. The +structure that holds a distance, has two members. The (cid:2)rst member is the tag +that speci(cid:2)es the type of distance being stored. The second member is the union +that holds the values for each of the possible distances. + +Exercise 4.2 There are two common notations for a point in a 2-dimensional space: +Cartesian coordinates and polar coordinates. Cartesian coordinates give a +pair +are: + +, the polar coordinates a pair + +. The meaning of + +and + ++(cid:8) + ++(cid:8) + +(cid:1)(cid:0) + +(cid:2)(cid:0) + ++ + +De(cid:2)ne a data type coordinate (both in SML and C) that can hold a point +in space in either of these coordinate systems. + +Exercise 4.3 Give a C function to convert a polar coordinate into a Cartesian coor- +dinate and give another C function to do the opposite. Are your functions +each other’s inverse? If not, can you (cid:2)nd a coordinate that when converted +suf(cid:2)ciently many times between polar and Cartesian ‘drifts’ away from the +initial coordinate? + +4.3.2 Pattern matching: the switch statement + +SML functions using algebraic data types need pattern matching to select which +data is stored. In C, this pattern matching is conveniently implemented using a +switch statement. The switch selects one out of many options in one operation: + +switch( (cid:0) ) { + +case (cid:3) + +(cid:2) : (cid:0) + +(cid:2) ; + +Revision: 6.37 + +(cid:1) +(cid:8) +(cid:14) +(cid:2) +(cid:8) +(cid:1) +(cid:0) +(cid:14) +(cid:1) +(cid:8) +(cid:14) +(cid:2) +(cid:8) +(cid:1) +(cid:0) +(cid:14) +(cid:8) +(cid:2) +(cid:0) +(cid:0) + 4.3. Unionsinstructs:algebraicdatatypes + +109 + +(cid:0) : (cid:0) + +case (cid:3) +... +default : (cid:0) + +(cid:0) ; + +(cid:1)(cid:0) + +; + +} + +The (cid:2)rst step of the execution of a switch statement is the evaluation of the ex- +pression (cid:0) . After that, the value of the expression is matched against all the (con- +stant) case labels (cid:3) +(cid:8) matches, the statements following +it, that is (cid:0) +(cid:8) , are executed. Otherwise, if none of the cases match, the statements +following the default label are executed. (The default part may be omitted, but +it is good programming practice to catch unforeseen cases using the default.) + +(cid:8) . If one of the constants (cid:3) + +The switch can be used to de(cid:2)ne the mm function, that converts any distance to + +millimetres: + +double mm( distance x ) { + +switch( x.tag ) { + +case Angstrom: return x.contents.angstroms * 1e-7 ; +case Kilometre: return x.contents.kilometres * 1e6 ; +case Mile: +case Lightyear: return x.contents.lightyears*9.4607e21; +default: + +return x.contents.miles * 1.609344e6 ; + +abort() ; + +} + +} + +int main( void ) { +distance x, y ; +x.tag = Mile ; += 1.0 ; +y.tag = Kilometre ; y.contents.kilometres = 4.0 ; +printf( "%f\n", mm( x ) + mm( y ) ) ; +return 0 ; + +x.contents.miles + +} + +The main program will add 1 mile and 4 kilometres, and print the result in mil- +limetres (5609344). + +The switch-statement has remarkable semantics, which a C programmer +must be aware of. When the execution of the selected statements has completed, +the program will normally continue to execute the statements following the next case +or default. This is called falling through. To prevent this from happening, either +a return or a break statement must be inserted in the statements that follow +each case label and the default label. A return will terminate the enclosing func- +tion, as is the case in the function mm shown before. A break will terminate the +execution of the switch statement, and continue with the (cid:2)rst statement after the +switch. + +All case labels in a switch statement must be unique. The order of the cases +is irrelevant since any expression will match at most one case. The default can +also be at any place, since it only matches if none of the constants match. However, +the order of the case labels is important if we wish to exploit the ‘falling through’ +property. Consider the following obscure, but legal, C function: + +Revision: 6.37 + + 110 + +Chapter4. StructsandUnions + +double double_power( double r, int p ) { + +switch( p ) { + +case 4 : r = r * r ; +case 3 : r = r * r ; +case 2 : r = r * r ; +case 1 : r = r * r ; + +} +return r ; + +} + +The function double_power calculates (cid:0) +(cid:1) as each successive multi- +plication is executed in turn. It is considered bad programming style to write this +kind of program. However, falling through is acceptable when several cases need +to be handled in precisely the same way. Here is a rather contrived example of +good use of falling through. The function legs counts the number of legs of the +species given: + +(cid:0)(cid:1)(cid:0) for % + +typedef enum { Ant, Ecoli, Lizard, + +Cat, Stork, Fuchsia } species ; + +int legs( species s ) { + +return 6; + +switch( s ) { +case Ant: +case Cat: +case Lizard: return 4; +case Stork: return 2; +return 0; +default: + +} + +} + +The expression legs( Cat ) evaluates to 4, just like legs( Lizard ). The ex- +pression legs( Fuchsia ) returns 0. + +4.3.3 Algebraic types in other imperative languages + +From a theoretical point of view the struc and union of C are well designed. +The language offers product types (the struct) and sum types (the union). These +are essentially separate concepts, so the language should have separate notations +for these concepts. However, from a programming point of view, it is not so clear +that these two concepts should be kept separate at all times. The problem is, that +as we have seen, there is nothing in a sum type (the union) to help us distinguish +between the various cases. The theorist has two notions of sum types: the disjoint +sum and the coalesced sum. The disjoint sum makes it possible to distinguish be- +tween the different variants of the sum type; the coalesced sum makes this impos- +sible. Such a distinction could have been made in C but it has not been. + +There is only one way to safely use a union in C, that is when the union is em- +bedded in a struct. In this context we can store, together with the union itself, the +tag that remembers which of the variants of the union is stored. The designers of + +Revision: 6.37 + +(cid:11) +(cid:12) +(cid:11) + 4.3. Unionsinstructs:algebraicdatatypes + +111 + +ALGOL-68 and Pascal found this such an important concept that they introduced +a construction that speci(cid:2)es both the variants and the tag, all at once. As an exam- +ple we show the C and Pascal de(cid:2)nitions of the point data structure: + +typedef struct { + +type point = record + +double x ; +double y ; + +} point ; + +x: real; +y: real; + +end; + +In Pascal, a (cid:3)oating point number is of type real. The words in a member decla- +ration in Pascal are written a different order. The enumerated types of Pascal and +C are similar: + +typedef enum + +{ Polar, Cartesian } +coordinatetype; + +type coordinatetype = + +( Polar, Cartesian ) ; + +The main difference between the two languages with respect to building struc- +tured data is that the Pascal record has a second use: it can have variants, which +correspond to the C struct/union combination. Here is the correspondence be- +tween the two languages: + +typedef struct { + +type coordinate = record + +coordinatetype tag ; +union { + +case tag : coordinatetype +of + +struct { + +double x ; +double y ; +} cartesian ; +struct { + +double r ; +double theta ; + +Cartesian: +( + +x : real; +y : real; + +); +Polar: +( + +r : real; +theta : real; + +} polar ; +} contents ; +} coordinate ; + +); + +end ; + +The Pascal coordinate record always has a tag member, which discrimi- +nates between the Cartesian and the Polar coordinate system. +If the tag is +Cartesian, then only the tag, x, and y members are logically accessible. A sim- +ilar restriction holds for Polar. The compiler can be designed to make sure that +the restriction is enforced. + +In the language C++, it was also recognised that a union is often part of a +In the + +structure. Hence, it was decided that a C++-union may be anonymous. + +Revision: 6.37 + + 112 + +Chapter4. StructsandUnions + +above example, the identi(cid:2)er contents can be omitted so that the union may be +de(cid:2)ned as: + +typedef struct { + +coordinatetype tag ; +union { + +struct { + +double x ; +double y ; +} cartesian ; +struct { + +double r ; +double theta ; + +} polar ; + +} ; + +} coordinate ; + +The de(cid:2)nition in C++ of a variable c of the type coordinate makes it possi- +ble to access the elements of c with c.tag, c.cartesian.x, c.cartesian.y, +c.polar.r, and c.polar.theta. This is opposed to the way the components +are accessed in C, using c.contents.cartesian.x. The use of tags is not +mandatory in C++, so unions like the one shown above are still unsafe. + +4.4 Pointers: references to values + +Until this moment, every data structure has been handled by value, in exactly the +same way as SML and other functional languages treat data structures. Handling +large data structures by value can be inef(cid:2)cient, as they must often be copied. In +SML, the compiler can optimise the code so that large data structures are passed +by reference instead of by value. In C, the programmer must explicitly use a call by +reference mechanism if data structures are not to be copied. + +In C, the call-by-reference mechanism is based on manipulating, not the data +itself, but pointers to the data. A pointer is a reference to a place where data is +stored, it is pointing to some data location. In terms of a von Neumann machine, a +pointer is the address of a memory location. A pointer is itself a value, so that one +can perform operations on a pointer as well as on the data. + +The pointer concept provides the means to implement any conceivable opera- +tion on data, but the mechanism itself is of a low level of abstraction. Its proper +use is more dif(cid:2)cult to master than the use of data structures in functional lan- +guages, but the rewards in terms of increased ef(cid:2)ciency may be considerable. Af- +ter explaining the basic principles of pointers, an example program will show how +pointers are used to improve ef(cid:2)ciency. + +4.4.1 De(cid:2)ning pointers + +Consider an example, where we have an integer i and a pointer p which refers to +i. In terms of a storage model, this can be visualised as follows: + +Revision: 6.37 + + 4.4. Pointers: referencestovalues + +113 + +123 + +i: + +p: + +The variable i is an integer with a current value 123; the variable p is a pointer +which refers to i. We say that p is a pointer referring to an integer, and the type +of p is ‘pointer to integer’. In C, this type is denoted as int *. The asterisk * +after the base type int indicates that this is a pointer to an int. The function +pointer_example contains declarations for i and p and initialises them: + +void pointer_example( void ) { + +int i = 123 ; +int *p = &i ; +printf("i: %d, *p: %d\n", i, *p ) ; + +} + +The variable p is initialised with the value &i. The pre(cid:2)x & is the address-operator, +it returns a reference to the variable, or, in terms of a von Neumann model, the +address of the memory cell where i is stored. The pre(cid:2)x-& can only be applied to +objects that have an address, for example a variable. The expression &45 is illegal, +since 45 is a constant and does not have an address. + +The call to printf prints two integer values, the values of i and *p. The +pre(cid:2)x-* operator is the dereference-operator. +It takes a pointer and returns the +value to which the pointer is pointing. It is the inverse operation of & and may +only be applied to values with a pointer type. Thus *i is illegal, as i is an inte- +ger (not a pointer), and *3.14e15 is also illegal as 3.14e15 is a (cid:3)oating point +number and not a pointer. The output of the function pointer_example will be: + +i: 123, *p: 123 + +Note that it is essential for i to be a variable, and not a const; it is illegal to ap- +ply the address operator to something that is denoted const. As with any other +type, a typedef can be used to de(cid:2)ne a type synonym for pointers. The type +pointer_to_integer is de(cid:2)ned below to be a synonym for a pointer to an int: + +typedef int * pointer_to_integer ; + +The general form of a pointer type is base_type *. The asterisk denotes ‘pointer +to’. The base_type may be any type, including another pointer type. This means +that we can use a type int **, which denotes a pointer to a pointer to an integer. +The asterisks bind from left to right, so this type is read as (int *)* or a pointer +to (a pointer to an integer). An extended function uses two more pointers, q and +r: + +void extended_pointer_example( void ) { + +i = 123 ; + +int +int *p = &i ; +int *q = &i ; +int **r = &p ; +printf("i: %d, *p: %d, *q: %d, **r: %d\n", i, *p, *q, **r ) ; + +} + +Revision: 6.37 + + 114 + +Chapter4. StructsandUnions + +Just before the printf function is called, the storage of i . . . r is initialised as +follows: + +123 + +i: + +p: + +q: + +r: + +The variable q is a pointer to an int and points to the same storage cell as p. The +variable r is a pointer to a pointer to an int; it is initialised to point to p. In the +call to printf, we (cid:2)nd the argument **r. The dereference operator * is applied +twice in succession, once to r, resulting in *r, the value to which r was pointing. +Subsequently *r is dereferenced resulting in *(*r) which results in the value of +i. The function above will print the output: + +i: 123, *p: 123, *q: 123, **r: 123 + +It is important to fully appreciate the meaning of the & and * operator. Note that +&i has the same value as p and q and that &p has the same value as r, but that &q +has a value different from r. + +Exercise 4.4 De(cid:2)ne a type pointer_to_pointer_to_double. + +Exercise 4.5 What is the meaning of the types type0 and type1 in the following + +type synonyms? + +typedef struct { + +double *x ; int y ; + +} type0 ; +typedef type0 *type1 ; + +Exercise 4.6 Consider the following: + +(a) Is *&i the same as i (given that i is a variable of type int)? +(b) Is *& (cid:8) +(c) Is &*p the same as p (given that p is a variable of type int *) +(d) Is &* +? + +the same as (cid:8) + +the same as + +for all (cid:8) ? + +for all + +4.4.2 Assignments through pointers + +After pointers have been de(cid:2)ned, one can not only access values through them (as +shown in the previous section), but also write values through pointers. Assign- +ing values through pointers is a low level activity, which can cause havoc in big +programs. Consider the following function: + +void pointer_assignment( void ) { + +int +int + +i = 123 ; +j = 1972 ; + +Revision: 6.37 + +(cid:5) +(cid:5) +(cid:5) + 4.4. Pointers: referencestovalues + +115 + +int *p = &i ; +int **r = &p ; +*p = 42 ; +*r = &j ; +*p = i + 1 ; +printf("i: %d, j: %d, *p: %d, **r: %d\n", i, j, *p, **r ); + +/* First assignment */ +/* Second assignment */ +/* Third assignment */ + +} + +The state of the store just after the initialisation and after each of the three subse- +quent assignments are shown in the following (cid:2)gure: + +Initial values + +Assignment 1 + +Assignment 2 + +Assignment 3 + +123 + +1972 + +i: + +j: + +p: + +r: + +42 + +1972 + +i: + +j: + +p: + +r: + +42 + +1972 + +i: + +j: + +p: + +r: + +42 + +43 + +i: + +j: + +p: + +r: + +At (cid:2)rst, p is pointing to i, and r is pointing to p. The (cid:2)rst assignment writes 42 to +*p. That is, it is not written to p but to the location where p is pointing to, which +is i. Thus the value of i changes from 123 to 42. The second assignment writes a +value to *r. Since r is pointing to p, the value of p will be overwritten with &j, a +pointer to j. The third assignment writes again to *p, because p is now pointing +to j, the value of j is changed. The output is therefore: + +i: 42, j: 43, *p: 43, **r: 43 + +By following the pointers, one can exactly determine which values are overwrit- +ten. However, viewed from a higher level, the semantics are awkward: + +(cid:1) Although the variable i is not assigned to anywhere in the function, its value +is changed. It was 123 after the initialisation, but it has the value 42 at the end +of the function. The value is changed because of the (cid:2)rst assignment to *p. + +(cid:1) The (cid:2)rst and the third assignment are both assignments to *p. Although +nothing has been assigned to p in the meantime, the (cid:2)rst assignment writes +to i, while the third one writes to j. The second assignment changes p by +assigning via *r. + +These ‘hidden’ assignments are caused by aliases. Immediately after the initialisa- +tion, there are three ways in this program to reach the value stored in i: via i, via +*p, and via **r. Because *p and **r both refer to i, they are called aliases of i. +Aliases cause a problem when one of them is updated. Updating one of the aliases +(for example *p or **r) can cause the value of all the other aliases to change. Up- +dating aliased variables can causes obscure errors, and it is recommended only to +update non-aliased variables. + +In a functional language aliases do exist, but the programmer does not have to +worry about them. As values cannot be updated, an alias cannot be distinguished + +Revision: 6.37 + + 116 + +Chapter4. StructsandUnions + +from a copy. Other languages do allow aliases, but some do not allow them to be +overwritten. + +4.4.3 Passing arguments by reference + +One of the main uses of pointers in C is to pass function arguments by reference, +instead of by value. Rather than passing the value to the function, we pass a +pointer to the value to the function. When used carefully, this has two advantages: + +1. Passing a pointer to a large data structure is more ef(cid:2)cient than passing the +data structure itself. Passing a data structure by value will cause the imple- +mentation to make a copy of the data structure and to pass that to the func- +tion, while passing a data structure by reference only passes a pointer. + +2. Data structures that are passed by reference can be modi(cid:2)ed. The modi(cid:2)ca- +tion of values should be performed with utmost care, as the modi(cid:2)cations +will be visible to any procedure using the data structure. + +To show these two advantages, we will use the core of a personnel information +system as an example. The personnel system stores the employee’s number, salary, +year of birth, and (cid:2)rst year of employment in a 4-tuple: + +(cid:1)(cid:3)(cid:2) + +(cid:4)(cid:6)(cid:5)(cid:7)(cid:2) + +(cid:5)(cid:9)(cid:2) + +(cid:5)(cid:9)(cid:2) + +(cid:4)(cid:9)(cid:8) + +employee (cid:0) + +The SML representation of this 4-tuple is: + +type employee = int * real * int * int ; + +The operation de(cid:2)ned on the type employee is a function that may be used to +give the employee a pay rise by a given percentage: + +(* payrise : employee -> real -> employee *) +fun payrise (nr, salary, birth, employed) inc + += (nr, salary * (1.0+inc/100.0), birth, employed) ; + +The C version of the data type employee is the following: + +typedef struct { + +int employee_number ; +double salary ; +int year_of_birth ; +int year_of_employment ; + +} employee ; + +There are two ways to implement the function payrise; it can be implemented in +an applicative way, or in an imperative way. Applicative means that data items, +Imperative means that data +once they have been created, will not be changed. +items may be changed. The applicative implementation of payrise follows the +pattern that we have seen before: + +employee payrise_ap( employee e, double inc ) { + +e.salary = e.salary * (1 + inc/100) ; +return e ; + +} + +Revision: 6.37 + +(cid:6) +(cid:4) + 4.4. Pointers: referencestovalues + +117 + +The structure containing the data on employee e is modi(cid:2)ed and returned Trac- +ing the execution of a program increasing the salary of one employee shows an +inef(cid:2)cient usage of memory and execution time: + +int main( void ) { + +employee e0 = { 13, 20000.0, 1972, 1993 } ; +employee e1 ; +e1 = payrise_ap( e0, 3.5 ) ; +return 0 ; + +, (cid:0) + +e0 : (13,20000.0,1972,1993) +e1 : ( (cid:0) +, (cid:0) + +, (cid:0) + +) + +} + +At Step 1 the function main has initialised the variable e0 with 4 values. The +struct e1 has an unde(cid:2)ned value (literally unde(cid:2)ned: it can be anything). + +employee payrise_ap( employee e, double inc ) { + +e.salary = e.salary*(1+inc/100); +return e ; + +} + +inc: 3.5 +e : (13,20000.0,1972,1993) +e0’: (13,20000.0,1972,1993) +e1’: ( (cid:0) +, (cid:0) + +, (cid:0) + +, (cid:0) + +) + +At Step 2 the function payrise_ap is called with two arguments, the value of e0 +and the value 3.5. On the stack, we (cid:2)nd the variables of main, and the arguments +of payrise_ap. The value of e is a complete copy of the value associated with +e0(cid:146) + +. + +employee payrise_ap( employee e, double inc ) { + +e.salary = e.salary*(1+inc/100); +return e ; + +} + +inc: 3.5 +e: (13,20000.0,1972,1993) +e0’: (13, 20000.0,1972,1993) +e1’: ( (cid:0) +, (cid:0) + +, (cid:0) + +) + +, (cid:0) + +At Step 3 the salary has been modi(cid:2)ed, and the whole structure is returned. Sub- +sequently, the new record is copied to the variable e1: + +int main( void ) { + +employee e0 = { 13, 20000.0, 1972, 1993 } ; +employee e1 ; +e1 = payrise_ap( e0, 3.5 ) ; +return 0 ; + +e0 : (13,20000.0,1972,1993) +e1 : (13,20700.0,1972,1993) + +} + +At Step 4 control has returned to main, and the return value of payrise_ap has +been copied into e1. The inef(cid:2)ciency in execution time arises from the fact that +the record has been copied two times (from e0 to the argument e and from e to +the variable e1). In terms of memory usage, the program is also inef(cid:2)cient: during +Steps 2 and 3, the stack contained three of the database records. The ef(cid:2)ciency can +be improved by not passing the structure, but by passing a pointer to the structure +instead and by working on the data directly: + +void payrise_im( employee *e, double inc ) { +(*e).salary= (*e).salary * (1+inc/100) ; + +} + +Revision: 6.37 + +(cid:0) +(cid:0) +(cid:0) +(cid:0) + 118 + +Chapter4. StructsandUnions + +The function payrise_im has two arguments. The (cid:2)rst argument e is a pointer +to a employee. The second argument inc is the percentage. The function result +is void, indicating that the function performs its useful work by means of a side +effect. In this case the return statement is usually omitted. + +The expression on the right hand side of the assignment statement calculates +the new salary of the employee. The expression (*e).salary should be read +as follows: take the value of the pointer e, dereference it to *e so that we obtain +the value of the whole employee record, and then select the appropriate member +(*e).salary, which is the salary of the employee. This pattern of (cid:2)rst derefer- +encing a pointer to a struct and then selecting a particular member of the struct +is so common that C allows more concise syntax for the combined operation: +e->salary. + +The assignment causes the new salary value to be written back into the salary +member of the object to which e is pointing. The structure that was passed as the +function argument is updated, this update is the side effect of the function. A truly +idiomatic C function can be created by using the -> and the *= operator (de(cid:2)ned +in Chapter 3): + +void payrise_im( employee *e, double inc ) { + +e->salary *= 1 + inc/100 ; + +} + +Remember that a *= b is short for a = a * b. To demonstrate the greater ef(cid:2)- +ciency of the use of payrise_im, we give the trace of a main program that calls +the function payrise_im. +int main( void ) { + +employee e0 = { 13, 20000.0, 1972, 1993 } ; +payrise_im( &e0, 3.5 ) ; +return 0 ; + +e0 : (13,20000.0,1972,1993) + +} + +Control starts in main, and the local variable e0 is initialised. Now payrise_im +is going to be called. + +void payrise_im( employee *e, double inc ) { + +e->salary *= 1 + inc/100 ; + +} + +inc : 3.5 +e : Points to e0(cid:146) +e0’: (13,20000.0,1972,1993) + +At Step 2 the function payrise_im has been called. Its (cid:2)rst argument, e, is not a +copy but a pointer to the employee structure associated with e0(cid:146) +. Consequently, +less storage is needed, and time is also saved because the employee structure has +not been copied. + +void payrise_im( employee *e, double inc ) { + +} + +e->salary *= 1 + inc/100 ; + +inc: 3.5 +e : Points to e0(cid:146) +e0’: (13,20700.0,1972,1993) +At Step 3 after the update of e->salary, the value of the variable e0(cid:146) +in the main +program has changed. The pointer e has been used both for reading the old salary, + +Revision: 6.37 + +(cid:0) +(cid:0) +(cid:0) + 4.4. Pointers: referencestovalues + +119 + +and for updating it with the new salary. + +int main( void ) { + +employee e0 = { 13, 20000.0, 1972, 1993 } ; +payrise_im( &e0, 3.5 ) ; +return 0 ; + +e0 : (13,20700.0,1972,1993) + +} + +At Step 4 control has returned to main, where the program can now inspect e0 in +the knowledge that it has been updated as a side effect of payrise_im. In com- +parison with the applicative version shown earlier, the structure has never been +copied, and at most one copy of the structure was present on the stack at any mo- +ment in time. What we have lost is clarity: given the old structure the applicative +version created a new structure, and did not touch any data private to main. The +imperative version modi(cid:2)es the local variables of main. + +The SML compiler might actually generate code comparable to the imperative +payrise_im. It would do so when the compiler can infer that the current em- +ployee record is no longer necessary after it has been updated. The programmer +should not have to worry about the safety of this optimisation, as the compiler +would not apply it when it would be unsafe to do so. + +Exercise 4.7 Reimplement the program of page 102, where a point was rotated + +around the origin. Implement it in such a way that + +1. The function print_point gets a pointer to a point as its argument. +2. The function rotate gets a pointer to a point as the argument, which +is modi(cid:2)ed on return. The function should have a return type void. +3. The function main calls rotate and print_point in the appropri- + +ate way. + +4.4.4 Lifetime of pointers and storage + +Passing around references to values opens a large trap in C. Consider the follow- +ing code fragment: + +int *wrong( void ) { + +int x = 2 ; +return &x ; + +} + +int main( void ) { + +int *y = wrong() ; +printf("%d\n", *y ) ; +return 0 ; + +} + +The function wrong is legal C; no compiler will complain about the code. The func- +tion has a local variable, initialised with the value 2, and a pointer to this value is +returned as the function result. The typing of this function is correct, since x is of + +Revision: 6.37 + +(cid:0) + 120 + +Chapter4. StructsandUnions + +type int, so &x is a pointer to an integer, int *, which happens to be the return +type of wrong. + +To see what the problem is, the function wrong has to be traced. Upon return- +ing from wrong, a pointer to x is returned, but when the function terminates, all +local variables and arguments of the function cease to exist. That is, the storage +cell that was allocated to x will probably be used for something else. This means +that x no longer exists, while there is still a pointer to x. In this particular pro- +gram, this pointer is stored in y in the main function. Such a pointer to data that +has disappeared is known as a dangling reference or a dangling pointer. The pointer +was once valid, but it is now pointing into an unknown place in memory. Using +this pointer can yield any result; one might (cid:2)nd the original value, any random +value, or the program might simply crash. + +To understand why a dangling pointer is created, the concept of the lifetime of +a pointer must be explained. Each variable has a certain lifetime. In the case of the +argument of a function, the variable lives until the function terminates. Ordinary +variables that are declared inside a block of statements, for example in the function +body or in the body of a while loop, are created as the block is entered and live +until that block of statements is (cid:2)nished. + +The rule to prevent a dangling pointer is: the pointer must have a lifetime that +is not longer than the lifetime of the variable that is being pointed to. In the ex- +ample of the function wrong, the return value of the function lives longer than +the variable x, hence there is a dangling pointer. In the main program that calls +payrise_im on page 118, the variable e0 lives longer than the pointer to it, which +is passed as an argument to payrise_im; therefore, there is no dangling pointer. +In later chapters, we will discuss other forms of storage with a lifetime that is +not bound to the function invocation: dynamic memory (Chapter 5), and global +variables (Chapter 8). With lifetimes that differ, dangling pointers become less ob- +vious. In larger programs it is also dif(cid:2)cult to (cid:2)nd errors with dangling pointers. +The symptoms of a dangling pointer may occur long after the creation of it. In +the example program wrong, y was used immediately in main. It is not unusual +for a dangling pointer to lay around for a long time before being used. The prob- +lems with dangling pointers are so common that there is a market for commercial +software tools that are speci(cid:2)cally designed to help discover such programming +errors. + +4.5 Void pointers: partial application + +The functions that have been discussed so far operate on one speci(cid:2)c type. This +can be a bit restrictive; it is useful to be able to create functions that have argu- +ments of a generic type. Pointers in C offer a mechanism that allows values of an +unspeci(cid:2)ed, generic type to be passed. To see why arguments of a generic type can +be useful, consider again the function bisection as discussed in Section 2.5.3. It +determines the root of a function in a given interval. It is likely that the roots of a +parametrised function may also be needed. For example, one might want to deter- + +Revision: 6.37 + + 4.5. Void pointers: partialapplication + +121 + +mine the roots of a family of functions, depending on some parameter (cid:3) : + +&(cid:10) + +parabola + +parabola + +The function de(cid:2)nes a parabola that has sunk through the X-axis with a depth (cid:3) . +The roots of this parabola are at the points (cid:0) +(cid:3) . (In Chapter 2, we used +(cid:6) ): +the function (cid:8) + +(cid:6) , which had a root at (cid:0) + +(cid:3) and (cid:0) + +Y-axis + +X-axis + +As another, slightly more involved example, one might want to determine a zero +of an even more general parabolic function which has the form below. This +parabola is parametrised over (cid:1) and (cid:3) : + +quadratic + +quadratic + +In a functional language, there are two ways to solve this problem. The (cid:2)rst +solution is to use partial application of functions. The functions parabola or +quadratic can be partially applied to a number of arguments before passing the +result to bisection. To see how this is done, de(cid:2)ne the SML function parabola +as follows: + +(* parabola : real -> real -> real *) +fun parabola c x = x * x - c : real ; + +The partially applied version of parabola with the value of c bound to 0.1 +is written as (parabola 0.1). This is a function of type real -> real and +therefore it is (cid:2)t to be supplied to bisection. Examples of evaluation include: + +bisection (parabola 2.0) 1.0 2.0 = 1.4140625 ; +bisection (parabola 4.0) 1.0 4.0 = 1.999755859375 ; + +Similar to the function parabola, we can write a function quadratic in SML as +follows: + +(* quadratic : real -> real -> real -> real *) +fun quadratic b c x = x * x - b * x - c : real ; + +To turn quadratic into a function suitable for use by bisection, we need to +partially apply it with two argument values, one for b and one for c. We can now +write the following expressions: + +bisection (quadratic 2.0 3.0) 1.0 +4.0 = 3.000244140625 ; +bisection (quadratic ˜2.5 8.1) 0.0 100.0 = 1.8585205078125; + +Revision: 6.37 + +(cid:0) +(cid:2) +(cid:6) +(cid:2) +(cid:6) +(cid:1) +(cid:8) +(cid:8) +(cid:0) +(cid:8) +(cid:0) +(cid:0) +(cid:3) +(cid:0) +(cid:0) +(cid:0) +(cid:0) +(cid:3) +(cid:0) +(cid:0) +(cid:3) +(cid:0) +(cid:2) +(cid:6) +(cid:10) +(cid:2) +(cid:6) +(cid:1) +(cid:8) +(cid:8) +(cid:0) +(cid:8) +(cid:0) +(cid:0) +(cid:1) +(cid:8) +(cid:0) +(cid:3) + 122 + +Chapter4. StructsandUnions + +The essential issue is that we use partial application of a function to aggregate a +function and a number of its arguments into a new function. Partial application +is not available in C, so we need to look for an alternative mechanism. The most +straightforward alternative is to pass not only the function of interest, but also any +extra arguments, as separate entities rather than as one aggregate. In both SML +and C, the de(cid:2)nition of bisection can be changed to pass the extra arguments. +Let us study the solution in SML (cid:2)rst. The revised version of bisection, called +extra_bisection, is given below. It has an extra argument x, whose only pur- +pose is to pass information to the call of the function f and to the recursive calls of +extra_bisection: + +(* extra_bisection : ((cid:146)a->real->real) -> + +(cid:146)a -> real -> real -> real *) + +fun extra_bisection f x l h + += let + +in + +val m = (l + h) / 2.0 +val f_m = f x m + +(* arg. x added *) + +if absolute f_m < eps + +then m +else if absolute(h-l) < delta + +then m +else if f_m < 0.0 + +(* arg. x added *) +(* arg. x added *) + +then extra_bisection f x m h +else extra_bisection f x l m + +end ; + +The de(cid:2)nition of parabola remains unaltered, as aggregating a single value into +a single argument does not make a visible change. The following call passes the +value 2.0 under the name x to the call f x m: + +extra_bisection parabola 2.0 1.0 2.0 + +The de(cid:2)nition of quadratic must be changed to aggregate the two arguments b +and c into one new, tupled argument: + +(* quadratic : real*real -> real -> real *) +fun quadratic (b,c) x = x * x - b * x - c : real ; + +The call extra_bisection quadratic (2.0,3.0) 1.0 4.0 passes the tu- +ple (2.0,3.0) under the name x to the places where the information is required. +Thus, if there is a single argument, it can be passed plain. If there are several +arguments, they must be encapsulated in a tuple before they are passed. The type +of the extra argument is denoted with a type variable (cid:146)a . A value of any type +can be passed, as long as the uses of the type (cid:146)a are consistent. This solution is +less elegant than the solution that uses partially applied functions because it re- +quires extra_bisection to pass the extra argument around explicitly. It is this +solution that we will use in C, because C has support for passing arguments of an +unknown type but no support for partial application. + +A C variable of type void * can hold a pointer to anything. For example, +a pointer to an integer, a pointer to a double, a pointer to a struct, and even + +Revision: 6.37 + + 4.5. Void pointers: partialapplication + +123 + +a pointer to a function can all be held in a void *. The language only in- +sists that it is a pointer to something. This means that the generalised version, +extra_bisection, can be implemented as follows: + +double extra_bisection( double (*f)( void *, double ), + +void * x, double l, double h ) { + +double m ; +double f_m ; +while( true ) { + +m = (l + h) / 2.0 ; +f_m = f( x, m ) ; /* argument x added */ +if( absolute( f_m ) < eps ) { + +return m ; + +} else if( absolute( h-l ) < delta ) { + +return m ; + +} else if( f_m < 0 ) { + +l = m ; + +} else { +h = m; + +} + +} + +} + +The argument f is a function that must receive two arguments: a pointer to some- +thing and a (cid:3)oating point number. When called, f returns a (cid:3)oating point number. +The extra argument x of extra_bisection must be a pointer to something. This +pointer is passed to the function f in the statement m = f( arg, m ) ;. The C +versions of parabola and quadratic must also be de(cid:2)ned in such a way that +they accept the extra arguments: + +double parabola( double *c, double x ) { + +return x * x - (*c) ; + +} + +The function parabola has two arguments: a pointer to a double c and a +double x. To obtain the value associated with c, the pointer must be dereferenced +using the asterisk. Note that the parentheses are not necessary; the unary * oper- +ator (pointer dereference) has a higher priority than the binary * (multiplication), +but for reasons of clarity, parentheses have been introduced. + +typedef struct { + +double b ; +double c ; + +} double_double ; + +double quadratic( double_double *bc, double x ) { + +return x * x - bc->b * x - bc->c ; + +} + +The function quadratic also has two arguments: the (cid:2)rst argument is a pointer +bc to a structure that contains two doubles, the second argument is the double + +Revision: 6.37 + + 124 + +Chapter4. StructsandUnions + +x. The structure double_double is unpacked in the body of quadratic; Then +bc->b is used to refer to the b argument, and bc->c refers to the c argument. + +Before extra_bisection can be called, its arguments must be wrapped ap- + +propriately, as is shown in the main function below: + +int main( void ) { + +c ; + +double +double_double dd ; +c = 2.0 ; +printf("%f\n", extra_bisection( parabola, /* Type error */ + +&c, 1.0, 2.0 ) ) ; + +c = 4.0 ; +printf("%f\n", extra_bisection( parabola, /* Type error */ + +&c, 1.0, 4.0 ) ) ; + +dd.b = 2.0 ; +dd.c = 3.0 ; +printf("%f\n", extra_bisection( quadratic,/* Type error */ + +&dd, 1.0, 4.0 ) ) ; + +dd.b = -2.5 ; +dd.c = 8.1 ; +printf("%f\n", extra_bisection( quadratic,/* Type error */ + +&dd, 0.0, 100.0 ) ) ; + +return 0 ; + +} + +The arguments that are to be passed to parabola and quadratic must be pre- +pared and stored before they can be passed. The & operator cannot be applied to +constant values, hence, the values to be passed to parabola (2.0 in the (cid:2)rst call +and 4.0 in the second call) are (cid:2)rst stored in a variable, c, whereupon the pointer +to this variable (&c) is passed to extra_bisection. Similarly, the structure dd +is (cid:2)lled with the appropriate arguments, whereupon a pointer to the structure is +passed to extra_bisection. + +There is one problem left in this implementation of main. The compiler will +not accept the calls to extra_bisection as they stand. The reason is that the +arguments parabola and quadratic are of the wrong type. The required type +is this: + +double (*)( void *, double ) + +The type offered by parabola is different; it is: + +double (*)( double *, double ) + +The type offered by quadratic is yet something else: +double (*)( double_double *, double ) + +The offered types cannot be accepted because the required type is: + +A function that accepts a generic pointer. + +The type offered by parabola is: + +A function that requires a pointer to a double. + +Revision: 6.37 + + 4.5. Void pointers: partialapplication + +125 + +The type offered by quadratic is: + +A function that requires a pointer to a double_double struct. + +To solve this type mismatch problem, we have to go back to the functions +parabola and quadratic to re-de(cid:2)ne them in such a way that they accept a +pointer to anything indeed: + +double parabola( void *p, double x ) { + +double *c = p ; +return x * x - (*c) ; + +} + +typedef struct { + +double b ; +double c ; + +} double_double ; + +double quadratic( void *p, double x ) { + +double_double *bc = p ; +return x * x - bc->b * x - bc->c ; + +} + +The function parabola now accepts a pointer to anything. Because it requires a +pointer to a double internally, it (cid:2)rst casts it to a pointer to a double. Type casts +from a void * to any pointer are always legal, hence the C compiler will translate +the assignment of void *p to double *c without complaints. These type casts +are implicit type casts, like the casts between integer and (cid:3)oating point numbers +(see page 33) where the compiler can introduce them without harm. Similarly, the +assignment from void *p to double_double *bc is without problems. + +4.5.1 The danger of explicit type casts + +It is enlightening to introduce explicit type casts. An explicit type cast has the fol- +lowing general form: + +( (cid:1) ) (cid:8) + +is the type to which the variable (cid:8) has to be cast. Therefore (double) 2 +Here (cid:1) +has the same type and value as 2.0. Likewise, the assignment in parabola above +could have been written: + +double *c = (double *) p ; + +Alternatively, the problem with the incorrect typing in main could have been +solved by calling extra_bisection with: + +extra_bisection( (double (*)(void *,double)) parabola, + +&c, 4.0, 7.0) ; + +/*initialise dd*/ +extra_bisection( (double (*)(void *,double)) quadratic, + +&dd, 4.0, 7.0 ) ; + +Revision: 6.37 + + 126 + +Chapter4. StructsandUnions + +This explains to the compiler that it should not bother with checking the types +of parabola and quadratic because it is told what the type is intended to be. +Although type-casts can be informative, they do have a serious disadvantage: the +compiler is not critical about explicit type casts. Any type cast is considered to be +legal, hence one could write: + +extra_bisection( (double (*)(void *,double)) 42, + +&dd, 1.0, 3.0 ) ; + +The integer number 42 is cast to the type ‘function with two arguments . . . ’ hence +it is a legal call to extra_bisection with the integer number 42 as a function. +Needless to say, the execution of this program is unpredictable, and most likely +meaningless. Because explicit type casts are unsafe, we discourage their use. In- +stead, we recommend relying on implicit type casts of the language. Although +they are not fool-proof, they are less error prone. + +4.5.2 Void pointers and parametric polymorphism + +There is an important difference between parametric polymorphism in a strongly +typed language and the use of void * in C. In a strongly typed language, dif- +ferent occurrences of the same type variable must all be instantiated to the same +type. In C, different occurrences of void * may represent different types, as the +type void * stands literally for a pointer to anything. As an example, consider +again the C version of extra_bisection, where the type void * appears twice +in the function prototype: + +double extra_bisection( double (*f)( double, void *), + +void * x, double l, double h ) + +The (cid:2)rst and the second declaration of void * have no relation according to the C +language de(cid:2)nition. This should be contrasted with the type of the SML de(cid:2)nition +of the same function which is: + +(* extra_bisection : ((cid:146)a->real->real) -> + +(cid:146)a -> real -> real -> real *) + +Here the type variable (cid:146)a refers to the one and the same type. In more complex +de(cid:2)nitions, various type arguments can be used ((cid:146)a , (cid:146)b , . . . ); in C, they are all the +same, void *. + +Type consistency is a valuable property as it prevents programming errors. In +the example above, the function extra_bisection could have been called as +follows: + +char t ; +extra_bisection( quadratic, &t, 0, 1 ) ; + +This is completely legal C: &t is a pointer to a character, so it conforms to the type +void *. The function quadratic requires a pointer to a structure, so it also con- +forms to the type void *. The fact that this character pointer is going to be used +(in quadratic) as a pointer to a structure is not noted by the compiler, since it +does not enforce the consistent use of polymorphic types. Polymorphism is dis- +cussed in more detail in Chapter 6. + +Revision: 6.37 + + 4.6. Summary + +127 + +Exercise 4.8 Rewrite the higher order function sum of Section 2.5.1 so that it is +non-recursive. Use it to implement a program that calculates the number +of different strings with at most +letters that you can make with (cid:8) different +letters. The number of strings is de(cid:2)ned by: + +(cid:14)(cid:16)(cid:15) + +You will have to pass (cid:8) as an extra argument through sum to the function +that is being summed. + +Exercise 4.9 Exercise 2.13 required you to approximate (cid:0) given a series. Rewrite it + +so that it calculates (cid:0) + +(cid:0) , for a real number (cid:8) + +. The function is given by: + +(cid:16)(cid:18)(cid:16)(cid:21)(cid:16) + +(4.2) + +(4.3) + +Eliminate all recursion from your solution. + +(cid:3)(cid:1) + +(cid:0)(cid:2)(cid:1) + +(cid:6)(cid:3)(cid:1) + +(cid:16)(cid:18)(cid:16)(cid:18)(cid:16) + +4.6 Summary + +The following C constructs have been introduced: +Data type constructors A struct can hold a collection of values, which are logi- +cally one entity. A union can hold one value of a number of different types +of values. They are de(cid:2)ned as follows: + +typedef struct + +/*optional name*/ { + +(cid:2) ; ... (cid:1)(cid:5)(cid:4) + +(cid:4) ; + +(cid:1)(cid:3)(cid:2) + +} (cid:1) ; + +typedef union + +/*optional name*/ { + +(cid:2) ; ... (cid:1)(cid:7)(cid:4) + +(cid:4) ; + +} (cid:1) ; + +(cid:8) and + +(cid:8) are the types and names of the members. The struct can op- +Here (cid:1) +tionally be supplied with a structure-name. (This will be discussed in Chap- +ter 6). +Structure and union members are accessed using the ‘.’ operator. The nota- +tion (cid:8) . +. + +accesses (cid:2)eld + +of variable (cid:8) + +Switch A switch statement allows the programmer to choose one alternative out + +of many. The switch statement has the following syntax: + +switch( (cid:0) ) { + +(cid:2) : (cid:0) +(cid:0) : (cid:0) + +case (cid:3) +case (cid:3) +... +default : (cid:0) + +} + +Revision: 6.37 + +(cid:15) +(cid:0) +(cid:14) +(cid:8) +(cid:27) +(cid:2) +(cid:4) +(cid:0) +(cid:0) +(cid:8) +(cid:2) +(cid:2) +(cid:8) +(cid:0) +(cid:2) +(cid:2) +(cid:8) +(cid:4) +(cid:8) +(cid:27) +(cid:2) +(cid:6) +(cid:15) +(cid:27) +(cid:2) +(cid:4) +(cid:0) +(cid:0) +(cid:0) +(cid:4) +(cid:0) +(cid:8) +(cid:9) +(cid:1) +(cid:8) +(cid:8) +(cid:0) +(cid:1) +(cid:0) +(cid:8) +(cid:1) +% +(cid:2) +(cid:8) +(cid:2) +(cid:2) +(cid:8) +(cid:0) +(cid:2) +(cid:12) +(cid:12) +(cid:1) +(cid:2) +(cid:12) +(cid:12) +(cid:12) +(cid:12) +(cid:12) +(cid:2) +(cid:0) + 128 + +Chapter4. StructsandUnions + +(cid:8) match, the statements following the default label, (cid:0) + +is evaluated, if it matches any of +(cid:8) . If none of the case la- +are executed. +(cid:8) should be unique. To jump to the end of the switch, a +(cid:8) will end with a break + +When executing the switch, the expression (cid:0) +(cid:8) , execution resumes at that point in the code, with (cid:0) +bels (cid:3) +The case labels (cid:3) +break ; statement should be used, usually each of (cid:0) +statement: +case (cid:3) + +(cid:8) ; break ; + +(cid:8) : (cid:0) + +Pointers Pointers are a reference to a value (a memory address). Pointers are +used, amongst others, to pass arguments by reference. For any but the basic +types this is more ef(cid:2)cient than passing arguments by value. Passing argu- +ments by reference allows a function to modify the argument. Such modi- +(cid:2)cations cause the function to have a side effect. The type of a pointer to (cid:1) +is denoted by (cid:1) *. Pointers are dereferenced using the unary * operator. A +pointer to a variable is obtained using the & operator. If (cid:12) +is a pointer to a +structure, then (cid:12) -> +accesses (cid:2)eld + +of *(cid:12) + +Void type The type void is used to indicate that a function does not have an ar- +gument or that it does not have a resulting value. The notation void * in- +dicates the type of a pointer to anything. + +The programming principles of this chapter are: + +Implement algebraic data types using structs and unions with a tag to dis- +criminate between the various alternatives of the union. The tag is essential +to distinguish between the various cases of the union. + +(cid:1) Passing large data structures around in C is inef(cid:2)cient in space and time. For +good ef(cid:2)ciency, the structures should be passed by reference. The disadvan- +tage of passing arguments by reference is that it makes it more dif(cid:2)cult to +reason about functions, as they might modify the arguments by a side effect. + +(cid:1) The lifetime of data should not be shorter than the lifetime of a pointer to +the data. For example, a function should never return a pointers to a local +variable. Otherwise the pointer will become a dangling pointer, which points +to non-existing space. + +(cid:1) Use general higher order functions with partially applied function argu- +ments instead of specialised functions. The mechanism in C supporting par- +tial application is at a lower level of abstraction than the mechanisms avail- +able in a functional language. +It requires care to use this mechanism, but +it is nevertheless a useful programming technique that is indispensable for +implementing large scale programs. Examples of its use, for example in the +X-windows library, are shown in Chapter 9. Another use of the void *, to +implement polymorphic types, is also discussed in Chapter 8. + +(cid:1) Do not rely on the C compiler to check consistent use of void * type point- +ers. Use the functional version of the solution to check the types carefully. + +Revision: 6.37 + +(cid:3) +(cid:12) +(cid:12) +(cid:1) + 4.7. Furtherexercises + +129 + +(cid:1) The use of type casts breaks the type system and thus reduces the opportu- +nity that the compiler has to detect errors in a program. Type casts should +thus be avoided. + +4.7 Further exercises + +Exercise 4.10 The C languages offers operators to create and dereference pointers. + +(a) Explain the relationship between the C language operators * and &. +(b) What is the output of the following program? + +int main( void ) { + +int i = 3 ; +int * p = & i ; +int * * q = & p ; +printf( "%d %d %d %d %d %d %d\n", + +3, i, p==*q, *p, q==& p, *q==&i, **q ) ; + +return 0 ; + +} + +(c) State what the output of the following program would be and explain + +why. + +int twice( int (*f) (int), int a ) { + +return f( f( a ) ) ; + +} + +int add( int a ) { +return a + 1 ; + +} + +int main( void ) { + +printf("%d\n", twice( add, 2 ) ) ; +return 0 ; + +} + +(d) Which are the differences between the program below and that of + +question (c)? + +int twice( int (*f) (int, int, int), + +int x, int y, int a ) { +return f( x, y, f( x, y, a ) ) ; + +} + +int add( int a, int b, int c ) { + +return a + b + c ; + +} + +int main( void ) { + +Revision: 6.37 + + 130 + +Chapter4. StructsandUnions + +printf("%d\n", twice( add, 2, 3, 4 ) ) ; +return 0 ; + +} + +(e) Which are the differences between the program below and that of + +question (d): + +typedef struct { + +int l, r ; + +} pair ; + +int twice( int (*f) ( void *, int ), + +void * x, int a ) { + +return f( x, f( x, a ) ) ; + +} + +int add( void * p, int c ) { + +pair * q = p ; +return q->l + q->r + c ; + +} + +int main( void ) { + +pair p = {2, 3} ; +printf("%d\n", twice( add, &p, 4 ) ) ; +return 0 ; + +} + +Exercise 4.11 Design a program that displays the character set of your computer +in a sensible way. Your solution should have a function that classi(cid:2)es a +character. Given a character, the function should return a structure that +identi(cid:2)es the class of the character and some information within the class. +The classes to be distinguished are: + +1. A digit. The numerical value of the digit must be returned as well. + +2. A lower case letter. In addition the index of the letter (1..26) must be + +returned. + +3. An upper case letter. In addition the index of the letter (1..26) must be + +returned. + +4. White space. Nothing extra needs to be returned. + +5. Something else. + +The rest of your program should call this function for each printable char- +acter and print the character, the numeric equivalent, and the classi(cid:2)cation +for all of them. + +Exercise 4.12 An accounting package needs to calculate net salaries given gross + +salaries, and gross salaries given net salaries. + +Revision: 6.37 + + 4.7. Furtherexercises + +131 + +(a) Previously, (cid:3)oating point numbers were used to represent money. This +is not proper, as the (cid:2)gure 1.01 cannot be represented exactly (Sec- +tion 2.4). Design a data structure that stores an amount of money with +a pair of integers, where one integer maintains the whole pounds (dol- +lar, yen, ...), and the other represents the pennies (cent, sen, ...). + +(b) De(cid:2)ne functions that operate on the money data type. The functions +should allow to add to amounts of money, subtract, and multiply a +sum with an integer, and divide a sum by an integer. The division +should round amounts to the nearest penny/cent/sen. + +(c) De(cid:2)ne a function that calculates the net salary given the following for- + +mula: + +(cid:2)(cid:18)(cid:13) + +(cid:26)% + +if (cid:13) +otherwise + +(cid:26)% + +if (cid:13) +otherwise + +%(cid:26)% + +%(cid:26)% + +(cid:31)%(cid:26)% + +%(cid:26)% + +%(cid:26)% + +if (cid:12) +if (cid:0) +if (cid:0) +otherwise + +(cid:26)% + +%(cid:26)% + +(cid:26)% + +%(cid:26)% + +is the gross salary, (cid:0) + +is after retirement contributions are taken + +is after insurance is taken out, and + +is the net salary. + +where (cid:13) +out, (cid:12) + +(d) De(cid:2)ne a function that determines a gross salary that someone has to +be paid in order to get a given net salary. Do not attempt to invert +the equations for (cid:12) and +(this is in real life often not feasible), instead +use the function de(cid:2)ned above and search for the right amount using +bisection. + +Exercise 4.13 A ‘Bounding Box’ is a concept used in 2-dimensional graphics. A +bounding box of a picture is de(cid:2)ned as the rectangular box that is just large +enough to contain the whole picture: + +Bounding +Box + +Assuming that the edges of the bounding box are parallel to the X and Y +axes, a bounding box is fully speci(cid:2)ed by a pair of coordinates: the coordi- +nates of the lower left hand corner and the upper right hand corner. +Bounding boxes need to be manipulated. In particular, If two elements of +a drawing have bounding boxes, the combined bounding box needs to be +calculated: + +Combined +Bounding Box + +Revision: 6.37 + +(cid:0) +(cid:0) +0 +(cid:1) +(cid:0) +% +(cid:14) +, +(cid:0) +(cid:9) +% +% +(cid:13) +(cid:14) +(cid:12) +(cid:0) +0 +(cid:0) +(cid:14) +, +(cid:0) +(cid:0) +(cid:9) +% +(cid:2) +(cid:0) +(cid:1) +(cid:0) +% +(cid:14) +(cid:15) +(cid:0) +(cid:6) +(cid:7) +(cid:7) +(cid:7) +(cid:8) +(cid:7) +(cid:7) +(cid:7) +(cid:9) +(cid:12) +(cid:14) +(cid:10) +(cid:0) +% +% +(cid:1) +(cid:12) +(cid:1) +(cid:9) +(cid:2) +(cid:6) +% +(cid:14) +% +% +(cid:11) +(cid:12) +(cid:10) +(cid:0) +(cid:9) +% +(cid:2) +(cid:12) +(cid:1) +(cid:9) +(cid:2) +(cid:9) +% +(cid:14) +(cid:9) +% +% +(cid:11) +(cid:12) +(cid:10) +(cid:6) +% +(cid:12) +(cid:1) +(cid:6) +(cid:2) +(cid:6) +% +(cid:14) +(cid:15) +(cid:15) + 132 + +Chapter4. StructsandUnions + +In general, two bounding boxes are combined by de(cid:2)ning a new bounding +box with the minimum (cid:8) and (cid:2) coordinates as the lower left corner and the +maximum (cid:8) and (cid:2) coordinates as the coordinates of the top right hand cor- +ner. De(cid:2)ne and implement the following: + +(a) A datatype to hold the bounding box. +(b) A function that normalises a bounding box (that is: it ensures that it +stores the lower left and upper right corners, and not, for example, the +lower right and upper left corners). + +(c) A function that combines two bounding boxes into one bounding box. +(d) A datatype to de(cid:2)ne a line. +(e) A datatype to de(cid:2)ne a circle. +(f) A datatype to de(cid:2)ne a rectangle. +(g) A datatype called element that can hold any of the line, circle, or rect- + +angle. + +(h) A function that takes a value of the type element and that produces + +the bounding box. + +(i) A main program that calculates the combined bounding box of the fol- + +lowing components: + +A circle at + +with radius (cid:0) , a rectangle with the corners at + +and + +, and a line from + +to + +. + +Assume in all of the above that the X and Y coordinates are stored in inte- +gers. + +Exercise 4.14 De(cid:2)ne a struct to represent some of the following 2D objects: cir- +cle, square, box, parallelogram, triangle, and ellipse. Then write a function +that when given a 2D object computes the area of the object. + +Exercise 4.15 Using the struct and function of the previous exercise, de(cid:2)ne an- +other struct that makes it possible to represent 3D objects, such as a +sphere, cube, cone, cylinder and pyramid. Write a function to compute the +volume of the 3D objects. + +Revision: 6.37 + +(cid:1) +(cid:6) +(cid:14) +(cid:6) +(cid:8) +(cid:1) +(cid:2) +(cid:14) +(cid:9) +(cid:8) +(cid:1) +(cid:9) +(cid:14) +(cid:1) +(cid:8) +(cid:1) +(cid:6) +(cid:14) +(cid:6) +(cid:8) +(cid:1) +(cid:4) +(cid:14) +(cid:0) +(cid:8) + c(cid:0) + +1995,1996 Pieter Hartel & Henk Muller, all rights reserved. + +Chapter 5 + +Arrays + +The C struct of the previous chapter provides the means to collect a small, (cid:2)xed +number of data items in a single entity. The items may be of different types. The +main topic of this chapter is the array data structure. An array gathers an arbitrary +number of elements into a single entity. The elements of an array must all be of the +same type. Sample applications of arrays are vectors of numbers and databases of +records. + +There are other data structures designed to store a sequence of data items of +identical type, the list for example. Although the purpose of lists and arrays is +the same, the data structures have different performance characteristics. For this +reason, some problems must be solved by using lists (arrays would be inef(cid:2)cient), +while for other problems the programmer should choose to use arrays (because +lists would be inef(cid:2)cient). + +Although lists and arrays can be expressed both in imperative and in func- +tional languages, the ‘natural’ data structure for both paradigms is different. Han- +dling arrays in a functional language can be inef(cid:2)cient, since a purely functional +semantics does not allow elements of the array to be updated without creating a +new version of the whole array. (We ignore the non-declarative extensions of SML +and sophisticated compiler optimisations designed to detect single threaded use +of arrays). Handling lists in C can be cumbersome, as memory has to be managed +explicitly. For these reasons, problems that do not have a speci(cid:2)c preference for +either lists or arrays are generally solved with lists in a functional language, but +implemented in C using arrays. In the next chapter we compare the ef(cid:2)ciency of +list and array representations. + +This chapter is the (cid:2)rst of three that discuss the implementation of sequences +of data. Therefore the present chapter starts with a model to explain how one can +reason about sequences. After that, the representation of arrays in C is explained. +Arrays in C are of a low level of abstraction, that is the programmer has to be con- +cerned with all details of managing arrays. Arrays in C can be used to build pow- +erful abstractions, that hide some of the management details. + +While discussing arrays, we present the concept of dynamic memory. This is +needed to implement dynamic arrays and also to implement lists in C, as shown +in Chapter 6. + +133 + + 134 + +Chapter5. Arrays + +5.1 Sequences as a model of linear data structures + +From an abstract point of view, an array is a sequence over a set of values. A se- +quence is de(cid:2)ned as a function from natural numbers to a set of values. A familiar +example is a string: it is a sequence of characters. A string can be interpreted as +a function by explicitly listing all possible argument/result pairs of the function. +We write such pairs using the ‘maplet’ symbol (cid:0) +. Here are the strings (cid:147)cucum- +ber(cid:148) and (cid:147)sandwich(cid:148) represented as functions (cid:3) and (cid:3) respectively. + +(cid:4)-(cid:10) + +(cid:1)(cid:0) + +(cid:0)(cid:2)(cid:0) + +(cid:6)(cid:3)(cid:0) + +(cid:9)(cid:4)(cid:0) + +(cid:4)(cid:3)(cid:0) + +(cid:6)(cid:5)(cid:0) + +(cid:23)(cid:26)% + +(cid:23)(cid:26)% + +(cid:1)(cid:0) + +(cid:0)(cid:6)(cid:0) + +(cid:6)(cid:3)(cid:0) + +(cid:9)(cid:3)(cid:0) + +(cid:4)(cid:4)(cid:0) + +(cid:6)(cid:5)(cid:0) + +(5.1) + +(5.2) + +they are zero-based. Further- +Note that these sequences start with the index 0: +more, each sequence numbers the elements consecutively. Indeed, sequences can +be generalised to start at arbitrary numbers, to leave ‘gaps’ in the domain, or to +use any other discrete domain. Such more advanced data structures include as- +sociative arrays and association lists. They are beyond the scope of this book; the +interested reader should consult a book on algorithms and data structures, such as +Sedgewick [12]. + +The advantage of the interpretation of an array as a sequence is that many use- +ful operations on sequences can be expressed using only elementary set theory. +We will discuss the (cid:2)ve most important sequence operations in the following sec- +tions. The (cid:2)rst three operations, taking the length of a sequence and accessing +and updating an element of a sequence, are used immediately when we de(cid:2)ne +arrays. The next two operations, concatenating two sequences and extracting a +subsequence from a sequence, are used when discussing lists in Chapter 6. + +5.1.1 The length of a sequence + +The length of a sequence is the cardinality of the set of argument/result pairs. We +will denote the cardinality of a set (cid:3) as (cid:8) +(cid:3) . For the set (cid:3) de(cid:2)ned by (5.2), we have + +(cid:0) . + +5.1.2 Accessing an element of a sequence + +To access an element of a sequence, we can apply the sequence (which is a func- +; for example, +tion!) to a natural number. The (cid:0) -th element of the sequence (cid:3) +is (cid:3) +the last character of the string (5.1) is (cid:3) +. The function to access an element +will almost always be partial. This means that an unde(cid:2)ned value is obtained if +we try to access an element of a sequence that is outside its domain, for example +(the symbol (cid:0) means ‘unde(cid:2)ned’). The notation with parentheses to ac- +cess an element of a sequence is actually used to access arrays in Fortran; in C, one +has to use square brackets to access the element of an array. + +Revision: 6.37 + +(cid:10) +(cid:3) +(cid:14) +(cid:3) +(cid:0) +(cid:2) +(cid:4) +(cid:3) +(cid:0) +(cid:10) +(cid:146) +(cid:3) +(cid:146) +(cid:14) +(cid:10) +(cid:146) +(cid:0) +(cid:146) +(cid:14) +(cid:10) +(cid:146) +(cid:3) +(cid:146) +(cid:14) +(cid:2) +(cid:0) +(cid:10) +(cid:146) +(cid:0) +(cid:146) +(cid:14) +(cid:1) +(cid:0) +(cid:10) +(cid:146) +(cid:12) +(cid:146) +(cid:14) +(cid:10) +(cid:146) +(cid:1) +(cid:146) +(cid:14) +(cid:10) +(cid:146) +(cid:0) +(cid:146) +(cid:14) +(cid:10) +(cid:146) +(cid:0) +(cid:146) +* +(cid:3) +(cid:0) +(cid:10) +(cid:146) +(cid:3) +(cid:146) +(cid:14) +(cid:10) +(cid:146) +(cid:0) +(cid:146) +(cid:14) +(cid:10) +(cid:146) +(cid:15) +(cid:146) +(cid:14) +(cid:2) +(cid:0) +(cid:10) +(cid:146) +(cid:25) +(cid:146) +(cid:14) +(cid:1) +(cid:0) +(cid:10) +(cid:146) +(cid:7) +(cid:146) +(cid:14) +(cid:10) +(cid:146) +(cid:0) +(cid:146) +(cid:14) +(cid:10) +(cid:146) +(cid:3) +(cid:146) +(cid:14) +(cid:10) +(cid:146) +(cid:14) +(cid:146) +* +(cid:8) +(cid:3) +(cid:0) +(cid:1) +(cid:0) +(cid:8) +(cid:1) +(cid:6) +(cid:8) +(cid:0) +(cid:146) +(cid:0) +(cid:146) +(cid:3) +(cid:1) +(cid:0) +(cid:8) +(cid:0) +(cid:0) + 5.1. Sequencesasamodeloflineardatastructures + +135 + +5.1.3 Updating an element of a sequence + +The third operation that we need is updating a sequence. When given a sequence +(cid:3) and an index (cid:0) +is the same as (cid:3) except +, then the sequence (cid:3) +at the index position (cid:0) where it has the value (cid:0) + +(cid:7)(cid:27) domain + +: + +(cid:1).(cid:2) + +(cid:5)/(cid:2) + +(cid:1)(cid:3)(cid:2) + +(cid:11)(cid:27) domain + +(5.3) + +For example, the sequence (cid:3) + +from (5.2) can be updated as follows: + +(cid:3)(cid:0) + +(cid:3)(cid:0) + +(cid:0)(cid:2)(cid:0) + +(cid:6)(cid:4)(cid:0) + +(cid:23)(cid:26)% + +(cid:9)(cid:3)(cid:0) + +(cid:4)(cid:4)(cid:0) + +(cid:6)(cid:5)(cid:0) + +5.1.4 The concatenation of two sequences + +To concatenate two sequences, the set union operator seems appropriate, but with +a twist. If we try to concatenate the two strings (cid:3) and (cid:3) above by naively writing + +(cid:3) , the result would be a relation but not a function: + +(cid:23)(cid:26)% + +(cid:3)(cid:0) + +(cid:3)(cid:0) + +(cid:0)(cid:2)(cid:0) + +(cid:0)(cid:2)(cid:0) + +(cid:6)(cid:3)(cid:0) + +(cid:6)(cid:3)(cid:0) + +(cid:4)(cid:3)(cid:0) + +(cid:4)(cid:3)(cid:0) + +(cid:6)(cid:5)(cid:0) + +(cid:6)(cid:5)(cid:0) + +(cid:9)(cid:3)(cid:0) + +(cid:9)(cid:3)(cid:0) + +When two sequences are concatenated, we must decide explicitly which one will +be the (cid:2)rst part of the resulting sequence and which one will the last part. The +domain of the sequence that will be the last part must be changed. To do this, we +de(cid:2)ne the operator (cid:3) + +to denote string concatenation as follows: + +(cid:1)(cid:3)(cid:2) + +(cid:4)-(cid:10) + +(cid:5)(cid:7)(cid:2) + +(cid:8)(cid:11)(cid:10) + +(cid:1)(cid:3)(cid:2) + +(cid:4)-(cid:10) + +Applying the concatenation operator to the two strings of (5.2) and (5.1) yields a +proper function: + +(cid:27) domain + +(5.4) + +(cid:23)(cid:26)% + +(cid:4)(cid:0) + +(cid:0)(cid:2)(cid:0) + +(cid:9)(cid:3)(cid:0) + +(cid:4)(cid:3)(cid:0) + +(cid:6)(cid:5)(cid:0) + +(cid:2)(cid:3)(cid:0) + +(cid:1)(cid:0) + +(cid:0)(cid:5)(cid:0) + +(cid:6)(cid:3)(cid:0) + +The de(cid:2)nition of the concatenation operator looks a bit complicated because con- +catenation is actually a complicated operation. When one array is concatenated +with another in a program, at least one of them must be copied to empty cells at +the end of the other. (If there are no empty cells, then both of them need to be +copied!) This notion of copying is captured by the change of domain for the sec- +ond sequence. + +Revision: 6.37 + +(cid:1) +(cid:3) +(cid:8) +(cid:1) +(cid:0) +(cid:0) +(cid:10) +(cid:0) +(cid:8) +(cid:3) +(cid:1) +(cid:3) +(cid:0) +(cid:10) +(cid:3) +(cid:8) +(cid:0) +(cid:4) +(cid:10) +(cid:1) +(cid:4) +(cid:5) +(cid:1) +(cid:8) +(cid:10) +(cid:4) +(cid:10) +(cid:1) +(cid:8) +(cid:3) +(cid:1) +(cid:0) +(cid:0) +(cid:10) +(cid:0) +(cid:8) +(cid:0) +(cid:23) +(cid:0) +(cid:0) +(cid:10) +(cid:3) +(cid:1) +(cid:0) +(cid:8) +(cid:29) +(cid:0) +(cid:1) +(cid:3) +(cid:8) +’ +(cid:0) +(cid:13) +(cid:0) +(cid:0) +* +(cid:2) +(cid:23) +(cid:0) +(cid:0) +(cid:10) +(cid:0) +* +(cid:3) +(cid:1) +% +(cid:10) +(cid:146) +(cid:0) +(cid:146) +(cid:8) +(cid:0) +(cid:10) +(cid:146) +(cid:0) +(cid:146) +(cid:14) +(cid:10) +(cid:146) +(cid:0) +(cid:146) +(cid:14) +(cid:10) +(cid:146) +(cid:15) +(cid:146) +(cid:14) +(cid:2) +(cid:0) +(cid:10) +(cid:146) +(cid:25) +(cid:146) +(cid:14) +(cid:1) +(cid:0) +(cid:10) +(cid:146) +(cid:7) +(cid:146) +(cid:14) +(cid:10) +(cid:146) +(cid:0) +(cid:146) +(cid:14) +(cid:10) +(cid:146) +(cid:3) +(cid:146) +(cid:14) +(cid:10) +(cid:146) +(cid:14) +(cid:146) +* +(cid:3) +(cid:2) +(cid:3) +(cid:2) +(cid:3) +(cid:0) +(cid:10) +(cid:146) +(cid:3) +(cid:146) +(cid:14) +% +(cid:10) +(cid:146) +(cid:3) +(cid:146) +(cid:14) +(cid:10) +(cid:146) +(cid:0) +(cid:146) +(cid:14) +(cid:10) +(cid:146) +(cid:0) +(cid:146) +(cid:14) +(cid:10) +(cid:146) +(cid:3) +(cid:146) +(cid:14) +(cid:10) +(cid:146) +(cid:15) +(cid:146) +(cid:14) +(cid:2) +(cid:0) +(cid:10) +(cid:146) +(cid:0) +(cid:146) +(cid:14) +(cid:2) +(cid:0) +(cid:10) +(cid:146) +(cid:25) +(cid:146) +(cid:14) +(cid:1) +(cid:0) +(cid:10) +(cid:146) +(cid:12) +(cid:146) +(cid:14) +(cid:1) +(cid:0) +(cid:10) +(cid:146) +(cid:7) +(cid:146) +(cid:14) +(cid:10) +(cid:146) +(cid:1) +(cid:146) +(cid:14) +(cid:10) +(cid:146) +(cid:0) +(cid:146) +(cid:14) +(cid:10) +(cid:146) +(cid:0) +(cid:146) +(cid:14) +(cid:10) +(cid:146) +(cid:3) +(cid:146) +(cid:14) +(cid:10) +(cid:146) +(cid:0) +(cid:146) +(cid:14) +(cid:10) +(cid:146) +(cid:14) +(cid:146) +* +(cid:3) +(cid:3) +(cid:3) +(cid:0) +(cid:1) +(cid:4) +(cid:10) +(cid:1) +(cid:1) +(cid:8) +(cid:3) +(cid:3) +(cid:1) +(cid:0) +(cid:3) +(cid:2) +(cid:23) +(cid:1) +(cid:0) +(cid:2) +(cid:8) +(cid:3) +(cid:8) +(cid:0) +(cid:10) +(cid:1) +(cid:1) +(cid:0) +(cid:8) +(cid:29) +(cid:0) +(cid:1) +(cid:1) +(cid:8) +* +(cid:3) +(cid:3) +(cid:3) +(cid:0) +(cid:10) +(cid:146) +(cid:3) +(cid:146) +(cid:14) +(cid:10) +(cid:146) +(cid:0) +(cid:146) +(cid:14) +(cid:6) +(cid:0) +(cid:10) +(cid:146) +(cid:3) +(cid:146) +(cid:14) +(cid:2) +(cid:0) +(cid:10) +(cid:146) +(cid:0) +(cid:146) +(cid:14) +(cid:1) +(cid:0) +(cid:10) +(cid:146) +(cid:12) +(cid:146) +(cid:14) +(cid:10) +(cid:146) +(cid:1) +(cid:146) +(cid:14) +(cid:10) +(cid:146) +(cid:0) +(cid:146) +(cid:14) +(cid:10) +(cid:146) +(cid:0) +(cid:146) +(cid:14) +(cid:0) +(cid:0) +(cid:10) +(cid:146) +(cid:3) +(cid:146) +(cid:14) +(cid:10) +(cid:146) +(cid:0) +(cid:146) +(cid:14) +(cid:0) +% +(cid:10) +(cid:146) +(cid:15) +(cid:146) +(cid:14) +(cid:0) +(cid:10) +(cid:146) +(cid:25) +(cid:146) +(cid:14) +(cid:0) +(cid:10) +(cid:146) +(cid:7) +(cid:146) +(cid:14) +(cid:0) +(cid:2) +(cid:0) +(cid:10) +(cid:146) +(cid:0) +(cid:146) +(cid:14) +(cid:0) +(cid:1) +(cid:0) +(cid:10) +(cid:146) +(cid:3) +(cid:146) +(cid:14) +(cid:0) +(cid:9) +(cid:0) +(cid:10) +(cid:146) +(cid:14) +(cid:146) +* + 136 + +Chapter5. Arrays + +5.1.5 The subsequence + +With the concatenation operator we can build larger sequences from smaller ones. +It is also useful to be able to recover a subsequence from a larger sequence. When +given that (cid:0) +of a sequence (cid:3) can be +de(cid:2)ned as follows: + +, then a subsequence (cid:3) + +(cid:27) domain + +(cid:16)(cid:18)(cid:16)(cid:18)(cid:16) + +(cid:1).(cid:2) + +(cid:5)(cid:7)(cid:2) + +(cid:4)(cid:6)(cid:5)(cid:7)(cid:2) + +(cid:4)/(cid:8)(cid:11)(cid:10) + +(cid:1).(cid:2) + +(cid:16)(cid:18)(cid:16)(cid:18)(cid:16) + +(cid:16)(cid:18)(cid:16)(cid:18)(cid:16) + +(cid:27) domain + +(5.5) + +The lower bound of the subsequence is (cid:0) , and the upper bound is +. The domain +of the resulting subsequence is changed, so that the index of the left most element +of every sequence is always 0. + +As an example, we will take the subsequence corresponding to the string (cid:147)and(cid:148) + +from the string (cid:147)sandwich(cid:148): + +(cid:16)(cid:18)(cid:16)(cid:21)(cid:16) + +(cid:3)(cid:0) + +(cid:0)(cid:2)(cid:0) + +(cid:6)(cid:3)(cid:0) + +(cid:23)(cid:26)% + +We now have at our disposal a notion of sequences based on elementary set the- +ory. Sequences will be used in this chapter to specify a number of operations on +In the next chapter, we shall look at alternative implementations of se- +arrays. +quences based on lists. + +5.2 Sequences as arrays in SML + +Arrays are not part of the SML language, but the SML/NJ implementation offers +the type array as part of the standard library. We will be using the SML/NJ ar- +ray to represent a sequence. Several functions are de(cid:2)ned on the type array; we +will brie(cid:3)y review the most important ones here. Like our sequences, arrays in +SML/NJ are zero-based. The index of the (cid:2)rst element is always 0, and the index +of the last element is always n-1 where n is the length of the array. + +5.2.1 Creating an SML array + +An array is created by one of two functions, array or tabulate. The (cid:2)rst is the +least powerful of the two: array(n,v) creates an array of length n such that +all array elements have the initial value v. This corresponds to the following se- +quence: + +array(n,v) (cid:0) + +(cid:23)(cid:26)% + +(cid:3)(cid:0) + +(cid:0)(cid:2)(cid:0) + +...(cid:1)(cid:13)(cid:15) + +The type of the SML array function is: + +(* array : int * (cid:146)a -> (cid:146)a array *) + +Revision: 6.37 + +(cid:14) +(cid:0) +(cid:1) +(cid:3) +(cid:8) +(cid:1) +(cid:0) +(cid:0) +(cid:8) +(cid:3) +(cid:1) +(cid:3) +(cid:3) +(cid:8) +(cid:0) +(cid:4) +(cid:10) +(cid:1) +(cid:4) +(cid:10) +(cid:1) +(cid:8) +(cid:3) +(cid:1) +(cid:0) +(cid:0) +(cid:8) +(cid:0) +(cid:23) +(cid:1) +(cid:0) +(cid:0) +(cid:0) +(cid:8) +(cid:0) +(cid:10) +(cid:3) +(cid:1) +(cid:0) +(cid:8) +(cid:29) +(cid:0) +(cid:1) +(cid:3) +(cid:8) +’ +(cid:0) +(cid:11) +(cid:0) +(cid:11) +(cid:0) +* +(cid:0) +(cid:3) +(cid:1) +(cid:0) +(cid:2) +(cid:8) +(cid:0) +(cid:10) +(cid:146) +(cid:0) +(cid:146) +(cid:14) +(cid:10) +(cid:146) +(cid:15) +(cid:146) +(cid:14) +(cid:10) +(cid:146) +(cid:25) +(cid:146) +* +(cid:10) +(cid:0) +(cid:14) +(cid:10) +(cid:0) +(cid:14) +(cid:0) +(cid:0) +(cid:8) +(cid:0) +(cid:10) +(cid:0) +* + 5.2. SequencesasarraysinSML + +137 + +The second SML function that can be used to create an array is more general: +tabulate(n,f) creates an array of length n corresponding to the sequence: + +tabulate(n,f) (cid:0) + +(cid:23)(cid:26)% + +(cid:3)(cid:0) + +(cid:8)(cid:16)(cid:14) + +(cid:0)(cid:2)(cid:0) + +...(cid:1)1(cid:15) + +(cid:8)(cid:16)(cid:14) + +(cid:1)(cid:13)(cid:15) + +The type of tabulate is: + +(* tabulate : int * (int->(cid:146)a) -> (cid:146)a array *) + +The function tabulate is more versatile and will be used in many cases. The +array function is only used for initialising an array that will be updated later. + +5.2.2 The length of an SML array + +The number of elements of an array s is given by the function length(s). This +corresponds directly with the operation (cid:8) on a sequence. The type of length is: + +(* length : (cid:146)a array -> int *) + +In SML/NJ the name length is used for both lists and arrays, but length is not +overloaded. When using arrays and lists in the same SML module one should be +careful to indicate whether Array.length or List.length is needed. + +5.2.3 Accessing an element of an SML array + +The function sub(s,i) accesses the i-th element of an array s. This corresponds +directly to accessing an element of a sequence using the operation (cid:3) +. Trying to +access an element that is not within the domain of the array gives an error. The +type of sub is: + +(* sub : (cid:146)a array * int -> (cid:146)a *) + +5.2.4 Updating an element of an SML array + +The (cid:2)nal operation that we need is an array update. This upd operation can be +de(cid:2)ned if we follow closely the speci(cid:2)cation of the sequence update (cid:3) + +: + +(* upd : (cid:146)a array * int * (cid:146)a -> (cid:146)a array *) +fun upd(s,k,v) = let + +val n +fun f i = if i = k + += length(s) + +then v +else sub(s,i) + +in + +tabulate(n,f) + +end ; + +Revision: 6.37 + +(cid:10) +(cid:0) +(cid:1) +% +(cid:10) +(cid:0) +(cid:1) +(cid:0) +(cid:0) +(cid:0) +(cid:8) +(cid:0) +(cid:10) +(cid:0) +(cid:0) +(cid:0) +(cid:8) +* +(cid:1) +(cid:0) +(cid:8) +(cid:1) +(cid:0) +(cid:0) +(cid:10) +(cid:0) +(cid:8) + 138 + +Chapter5. Arrays + +The function upd copies all elements of the old array s to a new array, except at +index position i, where the new value v is used. The old array s is not changed. + +5.2.5 Destructive updates in SML + +SML provides a built-in function update, which has a completely different be- +haviour from that of our function upd. The type of update is: +(* update : (cid:146)a array * int * (cid:146)a -> unit *) + +The result type of the function is unit, not (cid:146)a array. This implies that the func- +tion can only do useful work by updating one of its arguments as a side effect. In +this particular case it changes the contents of the array destructively. SML provides +the side effecting function update purely for ef(cid:2)ciency reasons. It is costly to cre- +ate a new array just to change one element. If the programmer knows that the old +array is not going to be needed again, then no harm is done by reusing the cells +occupied by the old array and changing its value. However, the function update +can be used only when the programmer is sure that the old contents of the array +are not going to be used again. + +In general, it is dif(cid:2)cult to know when it is safe to use update, so we discour- +age its use. In this book, we do not make use of update, so as not to blur the +division between the algorithmic aspects of programming, for which we use SML, +and the problem of creating ef(cid:2)cient programs, for which we use C. + +This completes the representation of sequences in SML. The implementation +of the two remaining useful functions corresponding to concatenation and subse- +quencing are left as an exercise. + +Exercise 5.1 Give an SML function concatenate(s,t) to concatenate two ar- + +rays s and t. + +Exercise 5.2 De(cid:2)ne an SML function slice(s,l,u) to return the data of the ar- +ray s from index l to index u as a new array. This corresponds to taking a +subsequence. + +5.3 Sequences as arrays in C + +Arrays form a proper part of the C language. In this section we give a brief general +overview of the arrays. We will elaborate each concept in considerable detail in +subsequent sections. + +5.3.1 Declaring a C array + +In C an uninitialised array is declared as follows: + +(cid:0) [ + +] ; + +Revision: 6.37 + +(cid:1) +(cid:15) + 5.4. Basicarrayoperations :Arithmetic mean + +139 + +is the type of the elements of the array, (cid:0) + +Here (cid:1) +is a +compile time constant (see below) giving the number of elements of the array. An +initialised array declaration has the general form: + +is the name of the array and + +(cid:0) [ + +] = { (cid:0) + +(cid:1) , (cid:0) + +(cid:2) , ... } ; + +(cid:2) must all be of type (cid:1) . The upper- +may be omitted from an initialised array declaration, in which case the + +The initial values of the array elements (cid:0) +bound +number of initial values determines the size of the array: +(cid:2) , ... } ; + +(cid:0) [] = { (cid:0) + +(cid:1) , (cid:0) + +(cid:16)(cid:18)(cid:16)(cid:18)(cid:16) + +It is possible for the explicit number of elements and number of initial values to +disagree. We will say more about this later. + +If an array is passed as an argument to a function the type of the array argu- + +ment is denoted as follows: + +(cid:0) [] + +is the type of the elements of the array (cid:0) + +Here (cid:1) +. C does not provide a facility to +discover the number of elements of an array argument. We will discuss this exten- +sively below. + +5.3.2 Accessing an element of a C array + +An array can be subscripted using the expression. + +(cid:0) [ (cid:0) ] + +is an array and (cid:0) + +Here (cid:0) +is an integer valued expression. As in our sequences and +in SML, the lower bound of an array in C is always 0. Thus the (cid:2)rst element of (cid:0) +is +the element with index 0. The upper bound of the array is the number of elements +in the array minus 1. For example, if an array has +elements, the array bounds are +% and + +(cid:0) . + +5.4 Basic array operations : Arithmetic mean + +We will now discuss the arrays of C in more detail. Consider the problem of cal- +culating the arithmetic mean of a sequence of numbers. The mean (cid:3) of a sequence +of numbers (cid:3) + +is de(cid:2)ned as: + +where + +(5.6) + +All numbers of the sequence are to be added together, and the sum should be di- +vided by the length of the sequence. Here is the SML algorithm to compute the + +Revision: 6.37 + +(cid:15) +(cid:1) +(cid:15) +(cid:1) +(cid:0) +(cid:4) +(cid:10) +(cid:15) +(cid:1) +(cid:1) +(cid:15) +(cid:15) +(cid:0) +(cid:3) +(cid:0) +(cid:2) +(cid:4) +(cid:10) +(cid:2) +(cid:6) +(cid:3) +(cid:0) +(cid:2) +(cid:6) +(cid:3) +(cid:0) +(cid:4) +(cid:10) +(cid:2) +(cid:0) +(cid:8) +(cid:9) +(cid:1) +(cid:3) +(cid:1) +(cid:0) +(cid:8) +(cid:15) +(cid:15) +(cid:0) +(cid:8) +(cid:3) + 140 + +Chapter5. Arrays + +mean of an array of reals: + +(* mean : real array -> real *) +fun mean s + += let + +in + +val n = length s ; +fun add_element sum i = sum + sub(s,i) + +foldl add_element 0.0 (0 -- n-1) / real(n) + +end ; + +The function mean computes the length of the array s. It then iterates over the +elements of the arithmetic sequence 0 -- n-1 and calls add_element for every +index from 0 to n-1. The expression sub(s,i) returns the i-th element of the +array s. The value of the array element is then added to the current sum. + +Exercise (cid:0) 5.3 Prove that SML function mean satis(cid:2)es the speci(cid:2)cation given by + +(5.6). + +The SML function mean can be transformed into an ef(cid:2)cient C function using the +increasing, left folding for schema of Chapter 3. The resulting, nearly complete C +implementation uses an increasing for loop: + +double mean( double s[] ) { +int n = /*length s*/ ; +int i ; +double sum = 0.0 ; +for( i=0 ; i < n ; i++ ) { + +sum = sum + s[i] ; + +} +return sum/n ; + +} + +The array argument of the function mean is declared as an array s of doubles: + +double s[] + +C does not provide an operation to determine the number of elements of an ar- +ray, hence the quali(cid:2)cation ‘nearly complete’ for the (cid:2)rst C version of mean. The +choice of not providing for a length operation was made for ef(cid:2)ciency reasons: not +having to maintain the length of an array saves space and time. However, in the +present case, we need the length of the array. The conventional solution to this +problem is to explicitly maintain the number of elements. In the case of the func- +tion mean, an extra argument n is passed specifying the number of elements of the +array. The de(cid:2)nitive version of mean becomes: + +double mean( double s[], int n ) { + +int i ; +double sum = 0.0 ; +for( i=0 ; i < n ; i++ ) { + +sum = sum + s[i] ; + +} + +Revision: 6.37 + + 5.4. Basicarrayoperations: Arithmeticmean + +141 + +return sum/n ; + +} + +Working with the number of elements of an array as opposed to the upper bound is +usual in C. It is important to see the difference, as the upper bound is one less than +the length. This is the reason that the for loop in the body of main tests on i < n: + +for( i=0 ; i < n ; i++ ) { + +The for loop operates over the domain % + +. Indeed almost any for loop + +in C that traverses an array has the following form: + +for( (cid:0) = 0 ; (cid:0) < + +; (cid:0) ++ ) + +This is opposed to the form: +for( (cid:0) = 1 ; (cid:0) <= + +; (cid:0) ++ ) + +Confusing the number of elements with the upper bound will lead to an ‘off by +one error’, accessing one element too many or too few. This is probably the most +common error amongst programmers (cid:3)uent in other languages but not used to the +particular way C handles arrays. + +To access an element of the array, the notation s[i] is used: s is the name +of the array and i is an expression which is used to index the array. The C ex- +pression s[i] is equivalent to the SML expression sub(s,i). In SML and many +other languages the indexing operator requires the index to be within the bounds +of the array that is being indexed. The C language does not require bounds to be +checked. Therefore, indexing an array with a large or negative index, for example +s[-100], might not result in a run time error, but will probably result in some +random value being returned. + +When an array is declared, the number of elements in the array must be speci- + +(cid:2)ed, as is shown in the main function used to test the function mean: + +int main( void ) { + +/* constant 4 used in the next line */ +double data[4] = { 55.0, 90.0, 83.0, 74.0 } ; +/* same constant 4 used in the next line */ +printf( "%f\n", mean( data, 4 ) ) ; +return 0 ; + +} + +In this program, data is an array that can store four doubles. The size of an array +must be a compile time constant. This means that the compiler must be able to cal- +culate precisely how long the array is. Any positive integer constant or an expres- +sion using only constants is legal. When an array is declared, it may be initialised, +using the curly brackets as shown in the second line of the function main. + +double data[ 4 ] = { 55.0, 90.0, 83.0, 74.0 } ; + +The (cid:2)rst value of the list, 55.0, will be assigned to the element with index 0, the +next one to the element with index 1, and so on, until the last value (74.0) is as- +signed to the element with index 3. If the number of elements in the list of initialis- +ers exceeds the capacity of the array, a syntax error will result. If fewer elements +are speci(cid:2)ed in the initialiser list, the remaining elements of the array will be ini- +tialised to zero. + +Revision: 6.37 + +(cid:11) +(cid:0) +(cid:10) +(cid:15) +(cid:15) +(cid:15) + 142 + +Chapter5. Arrays + +The main program for mean above uses the same constant 4 twice: once in the + +declaration of the array and once when calling mean. It is tempting to write: + +int main( void ) { + +const int array_length = 4 ; +double data[array_length] = { 55.0, 90.0, 83.0, 74.0 } ; +printf( "%f\n", mean( data, array_length ) ) ; +return 0 ; + +} + +Unfortunately, this is invalid C, as array_length is not a compile time constant, +despite the fact that it is obvious that it will always be 4. In general, the keyword +const means that the compiler marks the variables as read-only (that is, they can- +not be changed by the assignment statement) but it does not accept them as con- +stants. For proper constants, we have to use the C preprocessor, which offers a +macro facility. A macro is a means of giving a name to an arbitrary piece of text, +such that wherever the name appears, the piece of text is inserted. The macro def- +inition mechanism uses the keyword #define as follows: + +#define array_length 4 + +int main( void ) { + +double data[array_length] = { 55.0, 90.0, 83.0, 74.0 } ; +printf( "%f\n", mean( data, array_length ) ) ; +return 0 ; + +} + +The (cid:2)rst line declares that array_length is syntactically equivalent to 4. The text +array_length anywhere after this declaration will be replaced by the string 4. +This syntactic replacement can cause some unexpected behaviour as will be ex- +plained in Chapter 8. + +5.5 Strings + +In the second chapter, we introduced string constants. We postponed discussing +the type of this string constant. Now that arrays have been introduced, the type of +strings and their usage can be discussed in greater detail. + +In C, a string is stored as an array of characters. A string constant is denoted by +characters +(cid:0) charac- +characters hold the characters of the string, while the element with +(cid:0) -th element, as the (cid:2)rst element has index % ) holds a special char- +, signals the end + +a series of characters enclosed between double quotes ". If there are +between the quotes, the compiler will store the string in an array of +ters. The (cid:2)rst +index +acter, the NULL-character. The NULL-character, denoted as (cid:146)\0(cid:146) +of a string. + +(the + +The motivation for ending a string with a NULL-character is that any function +can now determine the length of a string, even though C does not provide a mech- +anism to determine the size of an array. By searching for the NULL-character, the +end of the string can be found. Note that a string cannot contain a NULL-character + +Revision: 6.37 + +(cid:15) +(cid:15) +(cid:2) +(cid:15) +(cid:15) +(cid:15) +(cid:2) + 5.5. Strings + +143 + +and that an array storing a string must always have one extra cell to accommodate +the (cid:146)\0(cid:146) +. Consider the de(cid:2)nition of a function that determines the length of a +string, strlen. This function is de(cid:2)ned as follows: + +(cid:1)(cid:3)(cid:2) + +strlen (cid:0) + +strlen + +In SML, the de(cid:2)nition of strlen just uses the primitive function size: + +(* strlen : string -> int *) +fun strlen a = size a ; + +In C, we will have to search for the NULL character as follows: + +int strlen( char string[] ) { + +int i=0 ; +while( string[i] != (cid:146)\0(cid:146) + +) { + +i++ ; + +} +return i ; + +} + +Each character of the string is compared with the NULL-character. When the +NULL character is found, the index of that character equals the length of the string +(as de(cid:2)ned in the beginning of this section). This function assumes that there will +be a NULL character in the string. If there is no NULL character, the function will +access elements outside the array boundaries, which will lead to an unde(cid:2)ned re- +sult. + +5.5.1 Comparing strings + +The function strlen above is one of a dozen string processing functions that are +prede(cid:2)ned in the standard C library. The most important of these functions are +discussed below, as they allow programmers to handle strings without reinvent- +ing string processing functions over and over again. To use these functions the +following include directive must be present in the program. + +#include + +The (cid:2)rst two functions to be discussed are functions that compare strings. In many +modern languages the relational operators, ==, >=, and so on, can be used to com- +pare arbitrary data. In C, the relational operators work on characters, integers, and +(cid:3)oating point numbers, but they do not operate structured data, and hence, not on +strings. Instead, the programmer must call a function strcmp. This function has +two strings as arguments and returns an integer: zero if the strings are equal, a +negative number if the (cid:2)rst string is ‘less than’ the second string, and a positive +number if the (cid:2)rst string is ‘greater than’ the second. Less than and greater than +use the underlying representation of the character set (as integers) to order strings. +The following inequalities are all true: + +strcmp( "monkey", "donkey" ) +> 0, +strcmp( "multiple", "multiply" ) < 0, + +Revision: 6.37 + +(cid:4) +(cid:10) +(cid:4) +(cid:8) +(cid:10) +(cid:2) +(cid:4) +(cid:1) +(cid:3) +(cid:8) +(cid:0) +(cid:8) +(cid:3) + 144 + +Chapter5. Arrays + +strcmp( "multi", "multiple" ) +strcmp( "51", "3" ) +strcmp( "51", "312" ) + +< 0, +> 0, +> 0 +A variant of strcmp, strncmp compares at most +characters. If no difference is +characters, the function strncmp returns 0, indicating that the +found in the (cid:2)rst +((cid:2)rst +characters of the) strings are equal. The number of characters to compare +is passed as the third argument of strncmp. Here are some expressions that use +strncmp: + +strncmp( "multiple", "multiply", 8 ) < 0, +strncmp( "multiple", "multiply", 7 ) == 0 + +5.5.2 Returning strings; more properties of arrays + +The functions strlen, strcmp, and strncmp all deliver an integer as the result +value (returning the length of the string or the result of the equality test). More +complicated operations, like string concatenation, require the returning of a string +as a result. In C, it is not possible for a function to return an array as a result. Ar- +rays in C are ‘second class citizens’. In a functional language, an array is a (cid:2)rst +class citizen in that it can be manipulated in exactly the same way as any other +data type. +In C, arrays cannot be assigned and an array cannot be returned as +function result. Furthermore, when an array is passed as an argument to a func- +tion, a special parameter passing mechanism is used. Instead of passing an array +by value, as is done for basic data types, an array is passed by reference. + +Because of these restrictions on arrays, functions that need to return a string (or +any other array) must do some in a special way. Below, we will introduce a (cid:2)rst so- +lution. Section 5.7 shows a more elegant method that requires the use of dynamic +memory. As an example program, we will discuss the function strcpy that copies +one array to another array. This is an operation which is not necessary in SML, but +in C it is a necessary operation (as strings cannot be assigned). Because the copy- +ing function cannot return a string, the array where the result appears is passed as +an argument to the function. The C program below de(cid:2)nes and uses the function +strcpy. This function is part of the standard library, so it is given here by way of +example only: + +void strcpy( char output[], char input[] ) { + +int i = 0 ; +while( input[i] != (cid:146)\0(cid:146) + +) { + +output[i] = input[i] ; +i = i + 1 ; + +} +output[i] = (cid:146)\0(cid:146) + +; + +} + +int main( void ) { +char s[ 10 ] ; +strcpy( s, "Monkey" ) ; + +Revision: 6.37 + +(cid:15) +(cid:15) +(cid:15) + 5.5. Strings + +145 + +printf( "The string (cid:146)%s(cid:146)\n", +return 0 ; + +s ) ; + +} + +The reason why strcpy works is that the array output, the destination of the +copy operation, is not passed by value, but by reference, following the model pre- +sented in Section 4.4.3. This means that the array is not copied, and only one ver- +sion of the array is present. Any changes made to the array s will be visible to +the calling function main. The function printf has a format to print strings, the +%s-format. + +An array is passed by reference because an array in C is not a collection of val- +ues, but only a pointer to the collection of values. It is fundamental to understand +the close relationship between arrays and pointers. The execution of the main pro- +gram above will allocate an array s, with space for 10 characters (indexed from 0 +to 9); s is a constant pointer to the (cid:2)rst cell (character) of the array. Just prior to call- +ing strcpy, the contents of all cells of s is unde(cid:2)ned. The picture below shows +both arguments of strcpy; These are s and the string "Monkey": + +s : + +"Monkey" : + +(cid:146)M(cid:146) + +(cid:146)o(cid:146) + +(cid:146)o(cid:146) + +The array s is not the collection of values +, but the reference +the collection of values +to the (cid:2)rst element. +(cid:146)M(cid:146) +(cid:146)e(cid:146) +(cid:146)n(cid:146) +, but a pointer to the (cid:2)rst of these values, +(cid:146)M(cid:146) +. When calling strcpy, these pointers are passed to the function strcpy. +When the function strcpy is about to return, the array s will have been updated +to contain the following values: + +Likewise, "Monkey" is not +(cid:146)y(cid:146) + +(cid:146)\0(cid:146) + +(cid:146)k(cid:146) + +(cid:16)(cid:18)(cid:16)(cid:18)(cid:16) + +output : + +input : + +s : + +(cid:146)M(cid:146) + +(cid:146)o(cid:146) + +(cid:146)n(cid:146) + +"Monkey" : + +(cid:146)M(cid:146) + +(cid:146)o(cid:146) + +The array itself (the pointer) is not changed, it is still the same reference to the +(cid:2)rst cell of the array. When returning from the function strcpy, the (pointer to +the) array s is passed to printf to print the copied string. Because the array is +passed as a pointer, an array parameter may also be declared as (cid:1) *. Here (cid:1) +is the +type of the elements of the array. The (cid:2)rst argument of strcpy can be declared +char *output, the second as char *input, this is the notation used in the C- +manual. + +Revision: 6.37 + +(cid:0) +(cid:0) +(cid:0) +(cid:1) +(cid:0) +(cid:14) +(cid:0) +(cid:14) +(cid:0) +(cid:14) +(cid:8) +(cid:1) +(cid:14) +(cid:14) +(cid:14) +(cid:14) +(cid:14) +(cid:14) +(cid:8) + 146 + +Chapter5. Arrays + +A disadvantage of passing the output array as an extra argument is that this +array might not be long enough to hold the copied string. If the array s declared +in main provided space for only three characters, the (cid:2)rst three character (cid:146)M(cid:146) +, +(cid:146)o(cid:146) +and (cid:146)n(cid:146) would end up in s, but the rest of the string would end up some- +where else (remember that the bound check is not performed). The results are +unpredictable. That this can be dangerous was demonstrated by the infamous +‘Internet-worm’ [13], a program that invaded and crashed thousands of UNIX ma- +chines worldwide by abusing, amongst others, a missing bound check in a stan- +dard UNIX program. + +To prevent strcpy from writing beyond the array upper bound, the length of +the array must be passed explicitly as a argument. The function strncpy has a +It will never overwrite more elements. The +third argument to pass the length. +function strncpy is generally preferred over strcpy. +In cases when the pro- +grammer can prove that the array is large enough, strcpy can be used instead. + +The functions strcat and strncat concatenate two strings. The concatena- +tion is different from functional concatenation as it destroys one argument on the +way. The (cid:2)rst argument of strcat is an array containing the initial string, the +second argument contains the string to be concatenated, and the concatenation is +performed in the (cid:2)rst argument. The (cid:2)rst argument serves both as the source and +as the destination of the function. + +The function strncat is the safe counterpart of strcat. It has a third argu- +ment specifying how many elements to concatenate at most. All the str... func- +tions discussed here are part of the string library. They are discussed in more detail +in Appendix C. + +5.5.3 An application of arrays and strings: argc and argv + +Most of the programs that we have seen so far are written for one speci(cid:2)c pur- +pose. They compute the answer to just the one problem that they are intended to +solve. The programs are not capable of (cid:2)nding solutions to even slightly different +problems. This is too restricted. It is possible to make programs a bit more (cid:3)exible +by allowing the user of the program to pass some information to it. In SML, one +would type the name of the main function and give various different arguments to +the function. In C, we can use something similar, but a little more effort is required +to make it work. The main function of a C program has hitherto been declared as +having the following type: +int main( void ) + +This type states that no information (void) is passed to the main function and that +an integer value should be returned. C permits us to declare the type of main as +follows: + +int main( int argc, char * argv[] ) + +This states that the function main takes two arguments: + +argc is an integer that tells how many strings are passed to the program. The + +value of argc is at least 1. + +Revision: 6.37 + + 5.6. Manipulating arraybounds,boundchecks + +147 + +argv is an array of strings. The (cid:2)rst string (with index 0) represents the name of +the program, for example a.out. The other strings are intended as proper +arguments to the program. In total there are argc (cid:0) +(cid:0) such arguments. If +argc equals 1, then no proper arguments are provided. The name of the +program, argv[0], is always present. + +Here is how argc and argv can be used. The following C program echoes its +arguments, with a space preceding each proper argument: + +#include + +int main( int argc, char * argv[] ) { + +int i ; +printf("program %s", argv[0] ) ; +for( i = 1; i < argc; i++ ) { +printf(" %s", argv[i] ) ; + +} +printf(".\n") ; +return 0 ; + +} + +After compiling this program to an executable (cid:2)le, say a.out, we could execute it +as follows: + +a.out one two three ! + +The program will then print the following line of text: + +program a.out one two three !. + +Exercise 5.4 Write a program that simulates the following game of cards. Player +A holds three cards on which four numbers are printed as follows: + +card 1 + +card 2 + +card 3 + +First, player B chooses a secret number between 0 and 7 (inclusive). Then +player A asks player B whether the secret number is on card 1 and notes +the answer (yes or no). Then player A asks whether the secret number is +on card 2 and also notes the answer. The same happens with card 3. From +the three answers, player A is able to work out what the secret number of +Player B was. + +5.6 Manipulating array bounds, bound checks + +In the previous section it has been shown that three issues regarding the bounds +of arrays in C are different from arrays in other languages: + +Revision: 6.37 + +(cid:0) +(cid:2) +(cid:9) +(cid:6) +(cid:6) +(cid:2) +(cid:4) +(cid:6) +(cid:1) +(cid:9) +(cid:4) +(cid:6) + 148 + +Chapter5. Arrays + +1. There is no support to determine the number of elements of an array. So +far we have seen two ways to solve this problem: by passing the length as +an argument or by declaring some value in the array ‘special’, for example +(cid:146)\0(cid:146) + +. + +2. Bound checks are not enforced by the language. Functions must test explic- + +itly on the bounds of arrays. + +3. The number of elements of any particular array is (cid:2)xed at compile time. + +To this list we could add a fourth issue: + +4. The lower bound of an array is always 0 in C. + +This is also the case in SML, and even in our sequences. There are however other +programming languages in which the lower bound of an array can be chosen +freely; Pascal is an example. The choice to give only rudimentary support for +arrays in C was made to improve execution speed. Programming convenience +has been sacri(cid:2)ced for sometimes signi(cid:2)cant improvements in execution speed. +This section shows how to use arrays with a lower bound that is not (cid:2)xed to zero, +and how to insert the proper bound checks. Section 5.7 will show a more (cid:3)exible +way to declare arrays, overcoming the limitation that the size of an array must be +known at compile time. + +As an example of using (cid:3)exible array bounds we will implement a program +that makes a histogram. A histogram is a bar graph that shows how often each +value occurs in a sequence of values. Given a string, a histogram can be used to +illustrate how often each character occurred in that string. The (cid:2)gure below shows +the histogram of the string (cid:147)abracadabra(cid:148). + +5 + +2 + +1 1 + +2 + +a b c d e f g h i + +j k l m n o p q r + +Making a histogram can be expressed conveniently in terms of sequences. A his- +is the sequence de(cid:2)ned as follows: +togram of a sequence (cid:3) + +(cid:1)(cid:3)(cid:2) + +(cid:1)(cid:3)(cid:2) + +(cid:4)(cid:9)(cid:8) + +histogram (cid:0) + +histogram + +(cid:23) ord + +(cid:20)(cid:27) + +range + +(5.7) + +Here we assume that the function ‘ord’ maps characters to natural numbers. In +SML, we are going to give a function histogram that counts characters in a par- +ticular range. The bounds of this range will be supplied as arguments. An array of +characters (represented in SML as an array of strings) is analysed, and the number +of times that each character is found is returned in an array indexed (indirectly) + +Revision: 6.37 + +(cid:4) +(cid:10) +(cid:4) +(cid:8) +(cid:10) +(cid:4) +(cid:10) +(cid:2) +(cid:1) +(cid:3) +(cid:8) +(cid:0) +(cid:1) +(cid:8) +(cid:8) +(cid:0) +(cid:10) +(cid:15) +(cid:29) +(cid:8) +(cid:1) +(cid:3) +(cid:8) +’ +(cid:15) +(cid:0) +(cid:8) +(cid:23) +(cid:0) +(cid:29) +(cid:3) +(cid:1) +(cid:0) +(cid:8) +(cid:0) +(cid:8) +* +* + 5.6. Manipulatingarraybounds,boundchecks + +149 + +with characters. A useful auxiliary function is inc below: it delivers a new ar- +ray, which is the same as the old one, except that a given array element has been +incremented by one: + +(* inc : int array -> int -> int array *) +fun inc s i = upd(s,i,sub(s,i) + 1) ; + +The histogram function (below) starts by calculating the length n of the array +input. The library function array creates a new array empty and initialises each +element to 0. The size of the new array is one more than the difference between +the upper bound u and the lower bound l. The tally function is then folded +over the index domain of the array input, calling inc to tally the occurrences of +each character in the input array input. The primitive SML function ord converts +the (cid:2)rst character of a string to its integer code. + +(* histogram : char array -> int -> int -> int array *) +fun histogram input l u + += let + +in + +val n = length input +val empty = array(u - l + 1,0) +fun tally hist i = inc hist (ord(sub(input,i))-l) + +foldl tally empty (0 -- n-1) + +end ; + +Exercise (cid:0) 5.5 Prove that the function histogram satis(cid:2)es the speci(cid:2)cation of + +(5.7) + +As was shown in the previous section on strings, C does not allow arrays to be +returned as function values. Therefore, we will de(cid:2)ne the function histogram in +such a way that the array in which the histogram is going to be written is passed +as an argument. This argument is passed by reference because it is an array. This +is the same method as used for the (cid:2)rst argument of strcpy. + +void histogram( char input[], int hist[], int l, int u ) { + +int i ; +/*C Make an empty histogram*/ +for( i=0 ; input[i] != (cid:146)\0(cid:146) + +; i++ ) { + +/*C Incorporate input[ i ] in the histogram*/ + +} + +} + +The (cid:2)rst argument contains the text for which a histogram is to be made. Since +the string is NULL terminated, the size of the array does not have to be passed as +an argument. The for loop that iterates over the array stops as soon as the NULL +character is recognised. The second argument is the array that will contain the +histogram, and the third and the fourth arguments are the bounds of this array. To +show how this function is going to be used, consider the following fragment of a + +Revision: 6.37 + + 150 + +main program: + +#define lower (cid:146)a(cid:146) +#define upper (cid:146)z(cid:146) +#define number (upper - lower + 1) + +Chapter5. Arrays + +int main( void ) { + +int hstgrm[ number ] ; +histogram( "abracadabra", hstgrm, lower, upper ) ; +print_histogram( hstgrm, lower, upper ) ; +return 0 ; + +} + +The histogram hstgrm is declared in the function main. It is an array of number +integers. The constant number is de(cid:2)ned as one more than the difference be- +tween the encoding upper of the upper bound (cid:146)z(cid:146) +and the encoding lower of +the lower bound (cid:146)a(cid:146) +. Assuming that the letters of the alphabet are encoded con- +secutively (which is the case for the common ASCII encoding, but not for the less +common EBCDIC encoding of characters), number will have the value 26. The ar- +ray hstgrm consists of 26 elements indexed from 0 to 25. Element 0 will be used +to tally the number of a’s, 1 to tally the b’s, . . . and element 25 to tally the z’s. + +The (cid:2)rst function to be called from main is histogram. Its (cid:2)rst argument is +the string "abracadabra" the remaining arguments are the array hstgrm, the +lower bound lower, and upper bound upper of the histogram. The (cid:2)rst action +of histogram should be to initialise the array. This initialisation is performed +conveniently by a for loop: + +for( i=0 ; i<=u-l ; i++ ) { + +hist[i] = 0 ; + +} + +The variable i runs from the lower bound of the array 0 to u-l, which is one less +than the number of elements of the array; each element is subsequently initialised +to zero. After the initialisation, another for loop should iterate over the input. Each +of the input elements of the input array is inspected in turn. According to the for +schema of Chapter 3, the body of the for loop should contain the following assign- +ment: + +hist = /*hist with one added at index input[i]*/ ; + +The functional version would make a new, updated array and use this new array +for the next version. This is not strictly necessary since the previous version of the +histogram is no longer needed. In C, the array hist is updated by incrementing +the value of the appropriate cell of the array. Given a particular index, of the ar- +ray element that needs to be incremented, the following statement will increment +the appropriate array element: + +hist[ /*index*/ ] ++ ; + +To calculate the appropriate value of /*index*/ the character values obtained +from the array input must be ‘shifted to the left’ by the lower bound l so that the +to (cid:146)z(cid:146) map onto the indices in the histogram 0 to 25. This shift oper- +letters (cid:146)a(cid:146) + +Revision: 6.37 + + 5.6. Manipulatingarraybounds,boundchecks + +151 + +ation is implemented by means of a subtraction on the characters (as explained in +Chapter 2). + +if( input[i] < l || input[i] > u ) { + +abort() ; + +} +hist[ input[i] - l ] ++ ; + +The if-statement veri(cid:2)es that the character input[i] is within the range l . . . u. If +it is not in range, the program will be aborted. This range check also catches a pos- +sible machine dependency of the type char, the possibility that some characters +are represented by negative numbers. Any negative character causes the program +to be aborted. + +A complete program that creates a histogram and prints the result is given be- +low. Arrays cannot be printed directly in C, instead they must be explicitly for- +matted. In this example, the histogram bars are formatted using lines of X-es. + +#include + +void histogram( char input[], int hist[], int l, int u) { + +int i ; +for( i=0 ; i<=u-l ; i++ ) { + +hist[i] = 0 ; + +} +for( i=0 ; input[i] != (cid:146)\0(cid:146) + +; i++ ) { + +/*Exercise 5.6*/ + +if( input[i] < l || input[i] > u ) {/*Exercise 5.6*/ + +abort() ; + +} +hist[ input[i] - l ] ++ ; + +/*Exercise 5.6*/ + +} + +} + +void print_xs( int n ) { + +int i ; +for( i=0 ; i int -> dynamic_array *) +fun array_alloc l u = (array(u-l+1,0),l,u) ; + +To create a dynamic array in C, the storage for it has to be allocated. This alloca- +tion operation is performed by calling the C library function calloc, de(cid:2)ned in +stdlib.h. The arguments passed to calloc are the number of cells needed and +the size of each cell. A dynamic array with a given pair of bounds therefore can be +allocated using the following function: + +#include + +dynamic_array array_alloc( int l, int u ) { + +dynamic_array da ; +da.lb = l ; + +Revision: 6.37 + + 154 + +Chapter5. Arrays + +da.ub = u ; +da.data = calloc( u - l + 1, sizeof( int ) ) ; +if( da.data == NULL ) { + +abort() ; + +} +return da ; + +} + +The lower and upper bounds l and u are arguments of +the function +array_alloc. The function stores the bounds in the dynamic_array structure +and calls calloc to allocate the store for the zero-based array. To obtain the size of +an element, C supports a built-in function sizeof, which returns the size in bytes +of an element of the speci(cid:2)ed type. The following expression returns the number +of bytes needed to store an integer: + +sizeof( int ) + +The number of bytes needed to store a dynamic_array structure is returned by +the expression: + +sizeof( dynamic_array ) + +This amount of store would cover one pointer and two integers. The store al- +located by calloc is guaranteed to be (cid:2)lled with zero-values. The result of +array_alloc is a proper dynamic array. + +The function calloc will normally return a pointer to a block of store that can +hold the required data. In exceptional situations, when the system does not have +suf(cid:2)cient space available, the function calloc will return a special pointer known +as the NULL-pointer. No valid pointer ever has the value NULL. By testing if the +value of da.data equals NULL, we can established whether the function calloc +has succeeded in allocating the memory. The program is aborted if calloc has +run out of space. Testing the value coming from calloc is recommended, as con- +tinuing a computation with a pointer that might be NULL will give random results: +the program might give an arbitrary answer or might crash. + +The function array_alloc shows that a dynamic array consists of two +parts: the zero-based array, which holds the actual data; and the struct of type +dynamic_array, which holds the bounds and a pointer to the zero-based array. +These are separate data structures, which makes it possible to manipulate them +separately. There is a danger in this, as one might think that just declaring a vari- +able of type dynamic_array creates a proper dynamic array: + +dynamic_array x ; /* WRONG */ + +This does not work, as the declaration merely creates the space necessary to hold +the pointer and the bounds. They are not properly initialised, nor is the zero based +array allocated. In terms of the model of the store, the result of this declaration is: + +x : + +Revision: 6.37 + +(cid:0) +(cid:0) +(cid:0) + 5.7. Dynamicmemory + +155 + +The two (cid:2)elds storing the upper and lower bound are unde(cid:2)ned, and the third +(cid:2)eld, which should point to a zero-based array, is also unde(cid:2)ned. The correct way +to use the dynamic array facility is by declaring and initialising the dynamic ar- +rays: + +dynamic_array x = array_alloc( l, u ) ; + +The function array_alloc will return an initialised dynamic array structure. +The (cid:2)rst and second (cid:2)eld will be initialised to l and u (representing the desired +lower and upper bounds of the array), and the third (cid:2)eld is allocated with a zero- +based array of + +(cid:0) elements. Here is a picture showing the results: + +x : + +l + +u + +0 + +0 + +5.7.2 The extension of dynamic arrays + +In the histogram program, a dynamic array must be extended when an element is +encountered that is not in the range of the array. Extending arrays is an expensive +operation, for in the general case, we may not assume that an array can be ex- +tended by claiming more space. The problem is that other dynamically allocated +data structures may occupy that extra space already. The only safe way of extend- +ing an array is by copying its contents to a new area of store, that does allow for +extra room. This problem is not speci(cid:2)c to C, any language that offers arrays is +faced with this dif(cid:2)culty. + +In SML, the extension of a dynamic array is taken care of by the function + +extend, shown below: + +(* extend : dynamic_array -> int -> int -> dynamic_array *) +fun extend (old,old_lb,old_ub) l u + += let + +in + +fun copy new i = upd(new,i-l,sub(old,i-old_lb)) + +(foldl copy (array(u-l+1,0)) (old_lb -- old_ub),l,u) + +end ; + +The function extend takes an old array, and new lower and upper bounds l and +u. It creates a new array which is large enough for the extended bounds and then +folds the function copy over the domain of the old array, so as to copy the old +array elements. + +The C implementation closely follows the pattern of the SML function extend: + +dynamic_array extend( dynamic_array old, int l, int u ) { + +dynamic_array new = array_alloc( l, u ) ; +int i ; +for( i=old.lb ; i<=old.ub ; i++ ) { + +Revision: 6.37 + +(cid:0) +(cid:0) +(cid:0) +(cid:2) + new.data[ i - l ] = old.data[ i - old.lb ] ; + +} +return new ; + +Chapter5. Arrays + +156 + +} + +The function extend takes an old array, and new lower and upper bounds l and +u. It (cid:2)rst allocates a new zero-based array that is large enough to handle the new +bounds. The data elements of this new zero-based array are automatically cleared +by array_alloc. The data from the old zero-based array are then transferred. +Finally the new zero-based array is returned to the caller. + +Exercise 5.7 Adapt the SML version of histogram so that it uses a dynamic ar- + +ray. + +The type dynamic_array, +together with the functions array_alloc and +extend, implement an abstract data type for dynamic arrays (more details on im- +plementing data abstractions are given in Section 8.4). + +The dynamic array can be used to implement the function histogram prop- + +erly (See section 5.7.3 for an explanation of the comments Leak!): +dynamic_array histogram( char input[], int n ) { + +dynamic_array hist = array_alloc( input[0], input[0] ) ; +int i ; +for( i=0 ; i hist.ub ) { + +hist = extend( hist, hist.lb, input[i] ) ; /*Leak!*/ + +} +hist.data[ input[i] - hist.lb ] ++ ; + +} +return hist ; + +} + +The function histogram (cid:2)rst allocates a one element dynamic array. We use the +(cid:2)rst character of the input as the initial lower bound and upper bound in order to +create a singleton array. (It is assumed that there is at least one character in the +input). + +The for loop over the input array performs two bound checks: if the charac- +ter is above the current bounds, the dynamic array is extended by stretching the +upper bound; and if the character is below the lower bound, the dynamic array +is extended to a new lower bound. After that, the character will fall within the +bounds, and the zero-based array hist.data is updated. Note the statement: + +hist.data[ input[i] - hist.lb ] ++ ; + +This has the same functionality as the statement (Section 3.3.4): + +hist.data[ input[i] - hist.lb ] = + +hist.data[ input[i] - hist.lb ] + 1 ; + +Revision: 6.37 + + 5.7. Dynamicmemory + +157 + +This demonstrates the advantage of using the ++ operator. The expression specify- +ing which element is to be incremented occurs twice in the second statement, but +only once in the (cid:2)rst. This means that if the expression needs to be changed for +some reason, it would require a consistent change of both copies of the expression +in the latter form, while one change suf(cid:2)ces for the (cid:2)rst form. +The main function using dynamic arrays is shown below. + +int main( void ) { + +dynamic_array hist = histogram( "abracadabra", 11 ) ; +int i ; +for( i = hist.lb ; i <= hist.ub ; i++ ) { + +printf( "%c: %d\n", i, hist.data[ i - hist.lb ] ) ; + +} +return 0 ; + +} + +An execution trace shows how the dynamic array is used. Immediately after the +function array_alloc is called, the dynamic array structure is (cid:2)lled with the fol- +lowing values: + +data: + +lb: + +ub: + +(cid:146)a(cid:146) + +(cid:146)a(cid:146) + +0 + +The upper bound and the lower bound are both (cid:146)a(cid:146) +, and the data is a pointer to +a single integer, which stores the value 0. The for loop is entered, and after the +(cid:2)rst iteration of the for loop the (cid:2)rst character of the string has been tallied, which +results in the following histogram: + +data: + +lb: + +ub: + +(cid:146)a(cid:146) + +(cid:146)a(cid:146) + +1 + +The bounds are unchanged, the element corresponding to (cid:146)a(cid:146) +in the histogram +has been incremented to re(cid:3)ect the single (cid:146)a(cid:146) +that has been counted. In the next +iteration of the for loop, the character (cid:146)b(cid:146) +is higher +than the upper bound; therefore, the dynamic array has to be extended. Immedi- +ately after the call to extend, the histogram will look as shown below. The upper +bound is now (cid:146)b(cid:146) +, the lower bound has not changed, and the histogram now con- +sists of two integers. The (cid:2)rst one is still 1, the second one has been initialised to +0. + +is encountered. The value (cid:146)b(cid:146) + +Revision: 6.37 + + 158 + +Chapter5. Arrays + +data: + +lb: + +ub: + +(cid:146)a(cid:146) + +(cid:146)b(cid:146) + +1 + +0 + +After the second iteration of the for loop, the new array element has been incre- +mented: + +data: + +lb: + +ub: + +(cid:146)a(cid:146) + +(cid:146)b(cid:146) + +1 + +1 + +The third character of the input is (cid:146)r(cid:146) +. This is higher than the upper bound, so +the dynamic array has to be extended again. This time, the extension results in the +following histogram: + +data: + +lb: + +ub: + +(cid:146)a(cid:146) + +(cid:146)r(cid:146) + +1 + +1 + +0 + +. . . + +0 + +The bounds have been set to (cid:146)a(cid:146) +, and the zero-based array now contains +18 integers which store the histogram values for (cid:146)a(cid:146) +. The (cid:2)rst two el- +ements of the histogram have been copied from the previous version (they have +both value 1). The other 16 cells of the array have been initialised to zeroes. + +up to (cid:146)r(cid:146) + +and (cid:146)r(cid:146) + +The rest of the input can now be processed, without extending the histogram, +. The end re- + +because all characters of (cid:147)abracadabra(cid:148) are in the range (cid:146)a(cid:146) +sult of the function histogram is the following: + +. . . (cid:146)r(cid:146) + +data: + +lb: + +ub: + +(cid:146)a(cid:146) + +(cid:146)r(cid:146) + +5 + +2 + +1 + +1 + +0 + +. . . + +0 + +2 + +Revision: 6.37 + + 5.7. Dynamicmemory + +159 + +This represents a dynamic array with a lower bound (cid:146)a(cid:146) +and a zero-based array of 18 integers with the values (cid:9) + +, an upper bound (cid:146)r(cid:146) + +, + +(cid:6) . + +5.7.3 The deallocation of dynamic arrays + +Reviewing the dynamic array based histogram program of the previous section +shows that there is something wrong with the use of the function extend. The +function takes the dynamic_array structure hist as an argument and returns a +new dynamic_array structure. This new structure is then written over the old +structure hist. The (cid:2)gure below shows the state of the relevant areas of store +at the point where hist has just been overwritten. The pointer to the old data is +shown as a dashed pointer; its place has been taken by the pointer to the new data, +shown as a solid pointer. + +data: + +lb: + +ub: + +(cid:146)a(cid:146) + +(cid:146)b(cid:146) + +1 + +1 + +0 + +Destroying the only pointer to an area of store causes the area to become inacces- +sible. In C such an inaccessible area of store will not be reclaimed automatically. +All functional languages have a garbage collector, and also some modern imper- +ative languages such as Java, Modula-3 and Eiffel have a garbage collector. This +is a component of the language implementation that detects when an area of the +store is not longer accessible so that it can be reused. Unfortunately, C and C++ do +not have garbage collectors, so the programmer must assume full responsibility +for the management of the store. + +When inaccessible areas of store are not reclaimed, a program may eventually +run out of available space. This situation is known as a memory leak because store +seems to disappear without warning. + +The inaccessible store of the old dynamic array must be deallocated explicitly +so that it can be reused later. This deallocation can be performed by calling the +function free, with the pointer to the block of store to be freed as an argument. +The function free will mark the block for reuse by calloc at a later stage. +The following call thus deallocates the block of store that was referenced from +hist.data: + +free( hist.data ) ; + +The new inner part of the for loop of the function histogram would read: + +dynamic_array new ; +if( input[i] < hist.lb ) { + +new = extend( hist, input[i], hist.ub ) ; +free( hist.data ) ; +hist = new ; + +Revision: 6.37 + +(cid:14) +(cid:6) +(cid:14) +(cid:0) +(cid:14) +(cid:0) +(cid:14) +% +(cid:14) +(cid:3) +(cid:3) +(cid:3) +% +(cid:14) + 160 + +Chapter5. Arrays + +} else if( input[i] > hist.ub ) { + +new = extend( hist, hist.lb, input[i] ) ; +free( hist.data ) ; +hist = new ; + +} + +Before the structure hist is overwritten with the new dynamic array new, the +memory cells pointed to by hist.data are deallocated, so that the function +calloc can reuse them later on. + +It is tempting to perform this deallocation as part of the function extend, for +example by modifying extend so that it deallocates the old zero-based array just +prior to returning the new dynamic array: + +dynamic_array extend( dynamic_array hist, int l, int u ) { + +dynamic_array new ; +/*Make the new dynamic array*/ +free( hist.data ) ; +return new ; + +} + +This implementation is particularly unclean because it is a halfway solution. Read- +ing the function header, it seems that it is a pure function that takes one dynamic +array and generates another. However, extend deallocates the old dynamic ar- +ray, which should therefore not be used afterwards. So extend is not a pure func- +tion, because it actually destroys (part of) its input. A better solution is to redesign +extend so that it announces that it relies on a side effect. By passing a pointer to +the old dynamic array and letting extend update the old dynamic array, the old +dynamic array cannot be accessed anymore, because it has been replaced by the +new dynamic array. The code with this destructive behaviour is shown below: + +void extend( dynamic_array * old, int l, int u ) { + +dynamic_array new = array_alloc( l, u ) ; +int i ; +for( i=old->lb ; i<=old->ub ; i++ ) { + +new.data[ i - l ] = old->data[ i - old->lb ] ; + +} +free( old->data ) ; +*old = new ; + +} + +dynamic_array histogram( char input[], int n ) { + +dynamic_array hist = array_alloc( input[0], input[0] ) ; +int i ; +for( i=0 ; i hist.ub ) { + +extend( &hist, hist.lb, input[i] ) ; + +} + +Revision: 6.37 + + 5.7. Dynamicmemory + +161 + +hist.data[ input[i] - hist.lb ] ++ ; + +} +return hist ; + +} + +The function extend takes a pointer to the dynamic array and updates this struc- +ture. To access the elements of hist, the arrow operator is used, since hist +is now a pointer to a structure, as opposed to the structure itself. Even though +extend relies on side effects and destructive updates, the function histogram is +still a pure function. As will be discussed in more detail in Chapter 8, from a soft- +ware engineering viewpoint it is important that functions have such a functional +interface. + +5.7.4 Explicit versus implicit memory management + +The functions calloc and free manage memory explicitly. This is in contrast +with the implicit memory management offered by languages with a garbage col- +lector. When a data structure is used in SML, the store that is needed for the data +structure is allocated automatically, that is, without the programmer being aware +of it or it being visible to the programmer. When structures are no longer used, +a garbage collector automatically reclaims the storage areas that are no longer in +use so that they can be reused for storage. The garbage collector of a declara- +tive language is implemented in such a way that only data structures that cannot +be reached by the program are reclaimed. This means that live data is never re- +claimed. + +The explicit memory management in C does not have this safeguard. The C +programmer decides when a block of store is to be reclaimed by calling the func- +tion free. If the C programmer makes a mistake and deallocates a block of store +that is actually still in use, a dangling pointer is created somewhere in the pro- +gram. As has been shown before, this will probably lead to random answers or a +program crash. To prevent dangling pointers we should make sure that data lives +longer than the pointer(s) to the data. + +In the case of explicitly allocated memory, the lifetime is completely deter- +mined by the programmer. The lifetime of a block of dynamically allocated store +ends when free is called. Therefore no pointers to that block of store should be +alive when the block is deallocated. It is good practice to destroy data in the same +function where the pointer to the data is destroyed (provided, that the pointer has +not been copied!). This was the case in the last version of the histogram program +and in an earlier version of the program where free was called from the function +histogram. In later chapters, we will see that this combined deallocation of the +block and destruction of the last reference to it is also the desired practice in other +programs. + +The problem of memory leaks is also related to the lifetime of pointers and +data. In this case the rule is exactly the opposite: memory does leak away if the +data has a lifetime that is longer than the pointer pointing to it, for if the pointer +is destroyed before the data is deallocated, the data cannot be deallocated any- + +Revision: 6.37 + + 162 + +Chapter5. Arrays + +more. This is a vicious circle. +If the pointer is destroyed before the memory is +deallocated, we have a memory leak, while if the memory is deallocated before +the pointer is destroyed, we have a dangling pointer. This is resolved by (cid:2)rst deal- +locating the memory and destroying the pointer shortly afterwards. + +Other languages, like C++, do have support to deallocate memory at the mo- +ment that pointers leave the scope. More advanced object oriented languages have +built-in garbage collectors that completely relieve the programmer of the burden +of managing the memory. + +5.7.5 Ef(cid:2)ciency aspects of dynamic memory + +The reason why C uses explicit memory management is ef(cid:2)ciency. From an exe- +cution time viewpoint, the allocation and deallocation of memory are costly oper- +ations. Allocating a block of memory takes probably one or two orders of mag- +nitude more time than performing a simple operation like comparing two num- +bers or indexing an array. Because C programmers (are supposed to) know that +memory allocation is time consuming, they will do everything possible to avoid +unnecessary allocation operations. + +In an ideal situation one would know a priori how large an array will have to +be. In this case the array can be allocated once with the right size and then used +without the need for extension. Information about the size of an array is often not +available at the right time (for example when reading the data to be incorporated +in the histogram from a (cid:2)le). Dynamic arrays provide a (cid:3)exible solution, that can +be highly ef(cid:2)cient if used with care. + +The way the dynamic array is used to construct a histogram is not expensive, +at least if the input data is long enough. The reasoning behind this is that the num- +ber of allocation operations will never exceed the number of different characters in +the input stream. Suppose that there are 70 different characters (letters, capitals, +digits, punctuation marks, and so on); if the input length is a 10000 characters, the +70 allocation operations add negligible overhead. + +However if the average length of the input data is about 7 characters, the cost +of allocation will far exceed the cost of making the histogram. The real work per- +formed is 7 index operations and increments, while the overhead is up to 7 alloca- +tion and deallocation operations. + +The functions calloc and free provide a mechanism to build data abstrac- +tions like the dynamic array, but they should be used with care. There is nothing +to protect the programmer from using these functions incorrectly (by deallocat- +ing memory at the wrong moment) or from using these functions too often. The +programmer has the control over the memory management and should not expect +any assistance from the compiler. + +Using another language, for example C++, does not help to relieve this per- +formance problem. Memory allocation is an expensive operation. Higher level +languages do succeed in hiding the details of memory allocation though, as is suc- +cessfully shown in SML. This does not mean that the penalty is not paid. It only +means that the programmer has no longer any control when the penalty is paid, + +Revision: 6.37 + + 5.8. Slicing arrays:pointerarithmetic + +163 + +and henceforth does not have to worry about it. + +5.8 Slicing arrays: pointer arithmetic + +So far, we have considered arrays as single entities which were passed as a whole +(albeit by reference). C has a mechanism that allows array slices to be passed. This +mechanism is known as pointer arithmetic. To illustrate the use of pointer arith- +metic, we will write a function that searches for the (cid:2)rst occurrence of word in a +text. In the speci(cid:2)cation below, both the word ( (cid:7) + +) and the text ( (cid:1) ) are sequences: + +(cid:1)(cid:3)(cid:2) + +(cid:5)(cid:7)(cid:2) + +search + +search + +(cid:0) min (cid:23) + +(cid:1)(cid:3)(cid:2) + +(cid:1)(cid:1)(cid:0) + +If the word (cid:7) does not appear in the text (cid:1) , the function min is asked to calculate +is +the minimum of an empty set. In this case we shall assume that the number (cid:0) +returned. + +To give a search algorithm let us assume that we (cid:2)rst try to match the word +with the text, starting at the (cid:2)rst position of the text. If this match fails, then we +move on to the second position and see if we can match the word there. If the +word occurs in the text then we will ultimately (cid:2)nd it, and return the present +starting position. Otherwise, we will exhaust the text, and return (cid:0) +(cid:0) . Here is a +schematic rendering of the (cid:2)rst three steps of the search process, where we have +chosen a word of length + +: + +Step 1: + +Step 2: + +Step 3: + +. . . + +. . . + +. . . + +The implementation of the search algorithm in SML takes as arguments the word +w and the text t. Both the word and the text are represented as an array of char- +acter. The function search also takes the current position i as argument. This +indicates where a match is to be attempted: + +(* search : char array -> char array -> int -> int *) +fun search w t i + += if i > length t - length w + +then ˜1 +else if slice (t,i,(i+length w-1)) = w + +then i +else search w t (i+1) + +Revision: 6.37 + +(cid:0) +(cid:4) +(cid:10) +(cid:1) +(cid:4) +(cid:10) +(cid:1) +(cid:8) +(cid:10) +(cid:2) +(cid:4) +(cid:1) +(cid:7) +(cid:14) +(cid:1) +(cid:8) +(cid:8) +(cid:1) +(cid:2) +(cid:29) +(cid:1) +(cid:0) +(cid:3) +(cid:7) +(cid:3) +* +(cid:0) +(cid:2) +(cid:1) +(cid:1) +(cid:1) +(cid:2) +(cid:1) +(cid:0) +(cid:1) +(cid:5) +(cid:1) +(cid:3) +(cid:7) +(cid:1) +(cid:7) +(cid:2) +(cid:7) +(cid:0) +(cid:1) +(cid:1) +(cid:1) +(cid:2) +(cid:1) +(cid:0) +(cid:1) +(cid:5) +(cid:1) +(cid:3) +(cid:7) +(cid:1) +(cid:7) +(cid:2) +(cid:7) +(cid:0) +(cid:1) +(cid:1) +(cid:1) +(cid:2) +(cid:1) +(cid:0) +(cid:1) +(cid:5) +(cid:1) +(cid:3) +(cid:7) +(cid:1) +(cid:7) +(cid:2) +(cid:7) +(cid:0) + 164 + +Chapter5. Arrays + +The function search is tail recursive. The main structure of the C version of +search is therefore easily written: + +int search( char *w, char *t, int i ) { + +while( true ) { + +if( i > strlen( t ) - strlen( w ) ) { + +return -1 ; + +} else if( /*slice of t equals w*/ ) { + +return i ; + +} else { + +i = i + 1 ; + +} + +} + +} + +Apart from some inef(cid:2)ciencies, which we will resolve later, we need to (cid:2)ll in how +to take the slice of t. The inef(cid:2)cient way to make a slice would be to allocate a +block of memory that is large enough to hold the slice, and to copy the relevant +cells of the array t into this new block of memory. C does however offer an alter- +native that does not require any cells to be copied. Instead, a different view on the +same array is created. + +To explain how this works, let us consider a simple example (cid:2)rst. Here is a +small main program with an array q of six characters. The array is initialised with +the string "Hello": + +int hello( void ) { + +char q[6] = "Hello" ; +char * r = q+2 ; +return r[0] == q[2] ; + +} + +As explained before, q is really a constant pointer to the (cid:2)rst of the six characters. +Now comes the interesting bit: in C it is permitted to add an integer to a pointer, +such that the result can be interpreted as a new pointer value. This is shown by +the statement r = q+2. The (cid:2)gure below shows the array q, and it also shows the +array r, which is merely another view on q. + +q: + +(cid:146)H(cid:146) + +(cid:146)e(cid:146) + +(cid:146)l(cid:146) + +(cid:146)l(cid:146) + +(cid:146)o(cid:146) + +(cid:146)\0(cid:146) + +r: + +(cid:146)H(cid:146) + +(cid:146)e(cid:146) + +(cid:146)l(cid:146) + +(cid:146)l(cid:146) + +(cid:146)o(cid:146) + +r[0] + +(cid:0) (q+2)[0] + +(cid:146)\0(cid:146) + +r[3] + +(cid:0) (q+2)[3] + +The expression (q+2), which ‘adds’ 2 to the array q, points to q[2]. Thus, (q+2) +is an array where the element with index 0, (q+2)[0], refers to q[2]. The ele- +ment with index 3, (q+2)[3], is the same element as the last element of q, q[5]. + +Revision: 6.37 + +(cid:1) +(cid:8) +(cid:1) +(cid:8) + 5.8. Slicing arrays:pointerarithmetic + +165 + +So the highest index that can be used on the array (q+2) is 3. The elements that +are shaded are still there, but they reside below the array. They can be accessed +using negative indices. Thus, the expression (q+2)[-2] refers to the lowest ele- +ment of the array q. The bounds of this array are -2 and 3, and the valid indices +for (q+2) are -2, -1, 0, 1, 2, and 3. Any other index is out of bounds and will, +because of the absence of bound checks, have unde(cid:2)ned results. + +The array (q+2) is almost a slice q(2 . . . 5) of the array q. There are two dif- + +ferences: + +1. (q+2) and q share the values of their cells. This is more ef(cid:2)cient; but if either + +is updated, the other one is updated. + +2. (q+2) still refers to the whole array q, the lower and upper parts are not + +physically detached. + +Note that the picture above only suggests that q and q+2 are different arrays, +whereas in reality they share the same storage space. + +Returning to the word search function, how can we use pointer arithmetic to +create a slice of the text and do so ef(cid:2)ciently? Firstly, the sharing implied by +pointer arithmetic is not a problem because the program that searches for a string +does not update either the array or the slice. The second problem from the enu- +meration above is a real one: the comparison between the slice and the array w +must only compare the section of the slice with indexes % +(cid:0) ; it should ig- +nore any cells below or above that range. The solution to this problem is to use +the function strncmp, which compares only a limited part of an array. Calling +strncmp with the start of the slice, and with the number of characters to compare +will give the desired result. Consider the following test: + +(cid:16)(cid:18)(cid:16)(cid:18)(cid:16) + +strncmp( t+i, w, strlen(w) ) == 0 + +The expression t+i results in a new view on t, shifted by i cells. So, as far as +the function strncmp is concerned, the (cid:2)rst element to compare is element t[i]. +Since strncmp does not look below this index, it does not matter that the rest of +the array is still there. Because no more than strlen(w) characters will be com- +pared, the upper part of t will also be ignored. + +Before giving the complete code of search, we remove some inef(cid:2)ciencies. +Observe that on every iteration of the while loop, the function strlen is called to +calculate the lengths of w and t. As these two lengths do not change, it is more ef- +(cid:2)cient to calculate each length only once, and to store the result in a local variable. +This leads us to the following complete and ef(cid:2)cient implementation of search: + +int search( char *w, char *t, int i ) { +const int length_w = strlen( w ) ; +const int length_t = strlen( t ) ; +while( true ) { + +if( i > length_t - length_w ) { + +return -1 ; + +} else if( strncmp( t+i, w, length_w ) == 0 ) { + +return i ; + +Revision: 6.37 + +(cid:8) +(cid:7) +(cid:0) + 166 + +Chapter5. Arrays + +} else { + +i = i + 1 ; + +} + +} + +} + +A sample main function to test the function search follows below. It assumes +that the word is passed as the (cid:2)rst argument to the program and that the text is +the second argument. + +int main( int argc, char *argv[] ) { + +if( argc != 3 ) { + +printf( "Wrong number of arguments\n" ) ; +return 1 ; + +} else { + +if( search( argv[1], argv[2], 0 ) != -1 ) { + +printf( "%s occurs\n", argv[1] ) ; + +} else { + +printf( "%s does not occur\n", argv[1] ) ; + +} +return 0 ; + +} + +} + +The process of searching something in a string is so common that the C library +provides standard functions for searching in strings. For example, the function +strstr implements the function search above. The function has a different in- +terface. It has only two parameters, and they are in reverse order: the text comes +(cid:2)rst, followed by the word. The return value is also different, instead of returning +the index of the element where the string was found, strstr returns a pointer to +that element. So the return type of strstr is char * and not int. Instead of re- +turning the index i, the function strstr returns the expression s+i, and instead +of returning the integer -1 on a failure, strstr returns the constant NULL. + +Here is a revised version of the main program above that uses strstr instead + +of our own function search: + +int main( int argc, char *argv[] ) { + +if( argc != 3 ) { + +printf( "Wrong number of arguments\n" ) ; +return 1 ; + +} else { + +if( strstr( argv[2], argv[1] ) != NULL ) { + +printf( "%s occurs\n", argv[1] ) ; + +} else { + +printf( "%s does not occur\n", argv[1] ) ; + +} +return 0 ; + +} + +} + +Revision: 6.37 + + 5.8. Slicing arrays: pointerarithmetic + +167 + +Above we have shown how addition to a pointer is used to shift an array, or to +make an array slice. The addition of an array and an integer, results in a shifted +view on that array. The inverse of this operation does also exist: two views on an +array can be ‘subtracted’ to determine how far one view is shifted with respect to +the other. The function strstr returns a pointer to the place where the string was +found, but using this subtraction it is now possible to determine the index: + +int main( void ) { + +char *q = "What a wonderful world!" ; +char *r = strstr( q, "wonderful" ) ; +char *s = strstr( q, "world" ) ; +printf("Indexes %d %d, diff %d\n", r-q, s-q, s-r ) ; +return 0 ; + +} + +The constant q points to the array of characters containing the string (cid:147)What a won- +derful world(cid:148). The (cid:2)rst call to strstr will return a pointer to the place where +(cid:147)wonderful(cid:148) appears in q. The second call to strstr returns a pointer to where +(cid:147)world(cid:148) appears. The printf statement prints three values: + +(cid:1) Firstly it prints the difference between r and q. They both point in the same +array of characters, and as q points to the beginning, r-q is equal to the in- +dex of where r was pointing to, 7. + +(cid:1) Secondly it prints the difference between s and q. This equals the index of + +the word (cid:147)world(cid:148) in q, which is 17. + +(cid:1) The third number is s-r, both are indices in the array pointing to q, the sub- +traction will result in 10, as s is pointing to q[17] and r is pointing to q[7]. + +The arithmetic with pointer works just like ordinary arithmetic as long as the point- +ers remain within the array bounds. The single exception being that a pointer that is +pointing just above the array is allowed, although this pointer should not be deref- +erenced. A number of interesting observations can now be made: + +(cid:1) The (cid:2)rst element of an array q is indexed with q[0], but as q is a pointer to + +the (cid:2)rst element, it can also be accessed as *q. + +In an array (q+2), the (cid:2)rst element is accessed with (q+2)[0], which is +referring to the same cell as q[2] (refer to the picture in the beginning of this +section). But in the previous bullet we observed that we could write *(q+2) +instead of (q+2)[0]. Thus, q[2] and *(q+2) are actually referring to the +same element. Indeed, in C, an expression of the form q[i] is by de(cid:2)nition +identical to the expression *(q+i). + +Pointer arithmetic is probably the concept for which C is (in)famous. Some people +loathe it, as it can lead to programs that are completely incomprehensible, other +programmers love it for the same reason. Pointer arithmetic is useful to create +array slices. For example, divide and conquer type applications can set functions +to work on two halves of an array by passing a pointer to the array itself and a + +Revision: 6.37 + +(cid:1) + 168 + +Chapter5. Arrays + +pointer to the middle. Care should be taken however when aliases are created with +pointer arithmetic, for example, when two slices (partially) overlap. As explained +in Section 4.4.2, aliases are a problem when they are updated. + +Pointer arithmetic works with arrays that are allocated dynamically in exactly +the same way as with arrays that are declared in the program. Pointer arithmetic +can also be used in conjunction with assignment statements. For example, if x is a +pointer to some (part of) an array, then the operation x++ will cause x to point to +the next cell. Again, this operation can be applied only as long as x points to the +same data. To conclude this section we will show an idiomatic C function, which +is used to copy a string: + +void copystring( char *out, char *in ) { + +while( *out++ = *in++ ) { + +/* Nothing more to do */ + +} + +} + +The while loop has a complicated conditional that contains three assignments. The +(cid:2)rst assignment is the = sign, it assigns one character from the in array to the out +array. The other two assignments are the ++ operators, which shift both in and +out one position further. To (cid:2)nish it off, the loop terminates if the character that is +copied happens to have the same representation of false, that is the (cid:146)\0(cid:146) +char- +acter. We do not recommend to use this style of code, but you will (cid:2)nd this style +of coding in real C programs. + +5.9 Combining arrays and structures + +Arrays and structs can be combined freely. It is possible to construct an array of +structures or a structure with one or more arrays as its components. Details of +these data types are discussed using a personnel database as a running example. + +In the previous chapter, we discussed the data type employee, which was de- +signed to record information about an employee of some company. Here we will +adapt the example in two ways. Firstly, slightly different information about the +employee is stored; the records of the database will now contain more detailed in- +formation. Secondly, the information for a number of employees is stored; we are +now actually building a database. The personnel database is intended for use by a +company that sells bicycles. The information to be maintained is the name of the +employee, the salary, the year of birth, and the number of bicycles sold over each +of the past (cid:2)ve years. The company has 4 employees. The manager of the com- +pany needs a program that increases the salary of each employee who sold more +than 100 bicycles on average over the last (cid:2)ve years. Here is the SML solution to +the problem: + +type employee = (string * real * int * int array) ; +type personnel = employee array ; + +(* mean : int array -> real *) + +Revision: 6.37 + + 5.9. Combiningarraysandstructures + +169 + +fun mean s + += let + +val n = length s +fun add_element sum i = sum + real(sub(s,i)) + +in + +foldl add_element 0.0 (0 -- n-1) / real(n) + +end ; + +(* enough_sales : employee -> bool *) +fun enough_sales (name, salary, birth, sales) + += mean sales > 100.0 ; + +(* payrise : employee -> real -> employee *) +fun payrise (name, salary, birth, sales) percent + += (name, salary * (1.0+percent/100.0), birth, sales) ; + +(* update_single : personnel -> int -> personnel *) +fun update_single p i + += if enough_sales (sub(p,i)) + +then upd(p,i,payrise (sub(p,i)) 10.0) +else p ; + +(* increase : personnel -> personnel *) +fun increase p = let + +val n = length p + +in + +foldl update_single p (0 -- n-1) + +end ; + +The function mean from the beginning of the chapter is reused here, but with +a different argument type. Here we are computing the mean of an array of in- +tegers instead of reals. The function enough_sales checks if the employee +has sold enough bicycles to meet the salary increment criterion. The function +update_single takes an employee and increases the salary with 10% if suf(cid:2)- +ciently many bicycles have been sold; increase will increase the salaries of all +employees who sold enough bicycles. It will not alter the salary of employees who +have not sold enough bicycles. + +When implementing this problem in C, the (cid:2)rst issue to consider is how to rep- +resent the data. As before, the SML tuple is represented by a struct, and the SML +array is represented by a C array: + +10 +#define n_name +#define n_sales +5 +#define n_personnel 4 + +typedef struct { + +char + +name[n_name] ; + +Revision: 6.37 + + 170 + +Chapter5. Arrays + +double salary ; +int +int + +year_of_birth ; +sold[n_sales] ; + +} employee ; + +typedef employee personnel[n_personnel] ; + +The (cid:2)rst three (cid:2)elds of the type employee specify the name (consisting of a maxi- +mum of 10 characters), the salary, and the year of birth of the employee. The fourth +(cid:2)eld is an array of 5 integers, used to store the sales over the past (cid:2)ve years. The +second type, personnel, de(cid:2)nes an array of employee. The de(cid:2)nition might +seem to be turned inside out, since the name of the type to be de(cid:2)ned appears in +the middle of the typedef. However, typedefs follow the same syntax as variable +declarations. A variable x that will hold 4 employees would have been declared: + +employee x[4] ; + +The C implementations of mean and enough_sales are not dif(cid:2)cult to write (see +below). The functions update_single and increase are more interesting to +implement. Increase runs a foldl over the range 0 . . . n-1. As has been shown +before in Chapter 3, this is implemented with a for loop. The operation to be per- +formed in the for loop is update_single: + +personnel update_single( personnel p, int i ) { + +if( enough_sales( p[i] ) ) { +p[i] = payrise( p[i] ) ; + +} +return p ; + +} + +/* INCORRECT C */ + +personnel increase( personnel old, int n ) { + +int i ; +personnel new = old ; +for( i=0 ; i 100.0 ; + +} + +void payrise( employee *e, double percent ) { +e->salary = e->salary * (1 + percent/100) ; + +} + +void update_single( personnel p, int i ) { + +if( enough_sales( p[i] ) ) { + +payrise( &p[i], 10 ) ; + +} + +} + +void increase( personnel p, int n ) { + +int i ; +for( i=0 ; iname, e->salary, + +e->year_of_birth ) ; + +for( i=0 ; isold[i] ) ; + +} +printf( "]\n" ) ; + +} + +The call to the function print_employee is changed accordingly: + +print_employee( &p[i] ) ; + +Although more ef(cid:2)cient, this implementation is less clear, because a user of the +function print_employee cannot be sure that the structure is not changed any- +more. + +5.10 Multi-dimensional arrays with (cid:2)xed bounds + +C has proper support for multi-dimensional arrays with (cid:2)xed boundaries. Such an +array is denoted with a sequence of bounds; one for each dimension. A two- +dimensional array for example has two bounds, and is thus an array of arrays. +Usually, a typedef is given for a multidimensional array, which (cid:2)xes the bounds. +Here is the typedef for a +(cid:9) matrix of integers: + +#define ROW 3 +#define COL 5 +typedef int matrix[ROW][COL] ; + +A multi-dimensional array can be initialised by listing the desired values for each +element. To initialise the +(cid:9) matrix we would list the desired values for the (cid:2)rst +row ( (cid:0)(cid:3)(cid:0) + +(cid:16)(cid:21)(cid:16)(cid:18)(cid:16) ), then those for the second row ( (cid:6) + +(cid:16)(cid:18)(cid:16)(cid:18)(cid:16) ) etc: + +matrix m = { {11,12,13,14,15}, +{21,22,23,24,25}, +{31,32,33,34,35} } ; + +A multi-dimensional array with (cid:2)xed bounds can be passed to a function. Here is +a function to print a matrix: + +void print_matrix( matrix m ) { + +int i,k ; +for( i = 0; i < ROW; i++) { +printf( "row %d:", i ) ; +for( k = 0; k < COL; k++) { + +printf( "\t%d", m[i][k] ) ; + +} +printf( "\n" ) ; + +Revision: 6.37 + +(cid:2) +(cid:5) +(cid:2) +(cid:5) +(cid:14) +(cid:0) +(cid:6) +(cid:14) +(cid:0) +(cid:14) +(cid:6) +(cid:6) +(cid:14) + 5.11. Summary + +} + +} + +175 + +The expression m[0][0] refers to the top left element, and the expression +m[ROW-1][COL-1] refers to the bottom right element. + +If the boundaries of the dimensions in a multi-dimensional array cannot be de- +termined statically, one should use an array containing pointers to further arrays. +Consult Kernighan and Ritchie for a further elaboration of this point [7, Page 110]. + +5.11 Summary + +The following C constructs were introduced: + +Array types Array types are denoted using square brackets. Static arrays must +have a compile time constant size. Dynamic arrays can be created using the +function calloc, which has two parameters, the size of an element and the +number of elements to allocate, it returns a pointer to the (cid:2)rst element of the +array. + +Array index Arrays are indexed with square brackets: + +is the ar- +ray and (cid:0) +is the (integer) index. The (cid:2)rst element of an array has index +0. The same notation can be used to identify an element to be overwritten. +(cid:0) [ (cid:0) ] = (cid:0) overwrites the (cid:0) -th element of (cid:0) with (cid:0) . + +(cid:0) [ (cid:0) ], where (cid:0) + +Array bounds C does not provide array bound checking. It is wise to either be +able to argue that array bounds cannot be exceeded or put explicit checks in +a program to make sure that the bounds are not exceeded. + +Arrays as function arguments and result In C, an array is not a set of values, but +a pointer to the set of values. The consequence is that when passing an ar- +ray as an argument, the array is passed by reference. Arrays should not be +returned as a function result, as only the pointer is returned, and the set of +values might cease to exist when the function terminates. Arrays allocated +explicitly can safely be passed around. + +Assignment to whole arrays It is not permitted to assign a new contents to an en- + +tire array at once. A loop should be used to achieve this. + +Pointer arithmetic Values can be added to a pointer, effectively slicing an array. + +The programming principles that we have encountered in this chapter are: + +(cid:1) An array is a sequence, that is, a mapping from natural numbers to some set + +of values. + +(cid:1) Working with arrays gives rise to a common programming error, the off by +one error; it is particularly easy to overrun the upper bound of an array by +mistaking the length for the upper bound. + +Revision: 6.37 + + 176 + +Chapter5. Arrays + +(cid:1) Beware of memory leaks, that is, use free on all data structures allocated by + +calloc. + +(cid:1) Make sure that a data structure is truly redundant before freeing it. Using + +free too early results in a dangling pointer. + +(cid:1) Attempt to deallocate memory in the same place where the last reference to + +a block is destroyed. This results in neat functions. + +(cid:1) Use void returning functions if the function does its useful work by a side +effect. Such functions are often called procedures. Do not use side effects +in proper functions. This ensures that functions and procedures are always +clearly identi(cid:2)ed. + +(cid:1) When side effects are necessary for ef(cid:2)ciency reasons, try to hide them in an +auxiliary function and provide a functional interface to the outside world. + +Many of the sequences in this chapter that have been implemented using arrays +could have been implemented with lists instead. The next chapter discusses the +implementation of lists in C. It also compares the two implementations of se- +quences from the point of view of their ef(cid:2)ciency. + +5.12 Further exercises + +Exercise 5.8 The last example program assumes that the company has 4 employ- +ees and 5 years of history. Modify the program to use dynamic arrays so +that an arbitrary number of employees and years of history can be main- +tained. (a further extension, storing the database on a (cid:2)le, can be found in +Chapter 7) + +Exercise 5.9 Rewrite your card simulation program from Exercise 5.4 so that it +plays a real game. When playing, the user should choose a secret number +and the program should try to ‘guess’ it. Here is sample dialogue with such +a program. The input of the user is underlined; the text produced by the +program is in plain font. + +Does the number appear on the first card: 1 3 5 7? y +2 3 6 7? n +Does it appear on the second: +And on the third: +4 5 6 7? n +Your secret number must be: 1! + +Exercise 5.10 In this exercise, create a function that prints a table of the months +of a year with the number of days in each month. Furthermore, write a +function that when given a particular date in a year calculates what date it +will be exactly one week later. + +Revision: 6.37 + + 5.12. Furtherexercises + +177 + +(a) Write a C function print_three to print the (cid:2)rst three characters of +a string. The function should have one argument (the string) and its +return type should be void. + +(b) Give the C type de(cid:2)nition of a structure month with two (cid:2)elds: an +integer days and a character string name. The string should have an +appropriately chosen maximum length. Use this declaration to create +an array of month called leap. Initialise the entries of the array with +the number of days in each month and the full name of the month. You +may assume that February has 29 days. + +(c) Create a function print_year that prints a table of the months of a +year with the number of days in each month. Your function should +take one argument, the array of month. +Its return type should be +void. Furthermore, print the total number of days in the year. This +should be computed by adding the days in all the months. Here is a +fragment of the output that your function print_year should pro- +duce: + +Jan. has 31 days +Feb. has 29 days +/*... rest of months*/ +Dec. has 31 days +This year has 366 days + +(d) Given a particular date in a year, for example February 24th, write a C +function that calculates what date it will be exactly one week later. In +a leap year, the answer should be March 2nd. Thus you will thus need +to know how many days each month has. Use the table of part(b) for +this purpose. Design a suitable interface for your function. + +Exercise 5.11 The bisection method of the previous chapters can be used not only +to search for the roots of a function but it can also be used to search ef(cid:2)- +ciently for some special item in non-numerical data. +(a) Modify extra_bisection from Section 4.5 to work with discrete +rather than continuous data. That is replace all types double by int +and reconsider the use of eps, delta and absolute. + +(b) Write a main function to call your discrete bisection function such that +it will search for an occurrence of a string in a sorted array of strings. +Use the arguments to your a.out to search for another occurrence of +a.out to test your code. For example, the following command should +produce the number 5, and it should make only two string compar- +isons. + +a.out a.1 a.2 a.3 a.4 a.out b.1 + +(c) Generalise the bisection function such that it can assume the role of the +discrete as well as the continuous bisection. Then rewrite your pro- +gram to use the generalised bisection rather than the discrete. + +Revision: 6.37 + + 178 + +Chapter5. Arrays + +Exercise 5.12 If you use a machine with a UNIX like operating system you might +try to write the following program that determines how much address +space your program is allowed to use. A standard UNIX function, brk, at- +tempts to set the highest address that your program may use (the ‘break’). +The function returns either 0 to indicate that the break was set successfully, +or 1 to signal that the break could not be set that high. Use the bisection +function of the previous exercise to (cid:2)nd the highest break that you can use +(assume that your system allows pointers and integers to be mixed, and +that the break is somewhere between 0 and 0x7FFFFFFF). + +Exercise 5.13 A program is needed to make sure that the exam results of the (cid:2)rst +year Computer Science students at your University are correctly processed. + +(a) De(cid:2)ne a two dimensional array for storing the exam results (inte- +gers in the range % +%(cid:26)% ) of the (cid:2)rst year Computer Science students. +Make sure that you choose appropriate upper bounds on the array(s) +for the number of students in your class and the number of modules in +your course. + +(cid:16)(cid:21)(cid:16)(cid:18)(cid:16) + +(b) Write a function to compute the sum of all the scores in the exam re- +sults table for a particular student and another function to count the +number of non-zero scores for a particular student. + +(c) Write a function to print the exam results as a nicely formatted table, + +with one line per student and one column per module: +(cid:1) Each row should be preceded by its row number. +(cid:1) Rows containing only zeroes should not be printed. +(cid:1) At the end of each row, print the sum, the number of non-zero + +scores and the average of the scores in the row. + +(d) Write a main function to create a table with some arbitrary values. + +Then call your print function on the table. + +(e) What measures have you taken to make sure that the exam results are + +processed and averaged correctly? + +Exercise 5.14 A particular spread sheet program has the following features: + +(a) The program knows about a (cid:2)xed maximum number of work sheets. +(b) Each work sheet has a name (of a (cid:2)xed maximum length), and a date + +and time of when it was last used. + +(c) Each work sheet is a rectangular 2-dimensional array of cells with + +bounds that will not exceed certain (cid:2)xed maximum values. + +(d) The are four kinds of cells: a formula (represented as a string of a (cid:2)xed + +maximum length), an integer, a real number, or a boolean. + +(e) The spread sheet program should be able to tell what kind of cell it is + +dealing with. + +(f) Each cell has a (cid:3)ag stating whether it is in use or not. + +Design the C data structures required to support all these features by giving +#define and typedef declarations. Do not write the rest of a program that +might use the data structures. + +Revision: 6.37 + +(cid:0) + 5.12. Furtherexercises + +179 + +Exercise 5.15 A magic square [8] of order + +is a square in which the numbers + +(cid:16)(cid:18)(cid:16)(cid:21)(cid:16) + +(cid:0) are arranged in the following way: + +(cid:1) Each number appears exactly once. + +(cid:1) The sum of the numbers in each row is the same. + +(cid:1) The sum of the numbers in each column is the same. + +(cid:1) The sum of the numbers in each of the two main diagonals is the same. + +(cid:1) All sums above are the same. + +Here is a magic square of order 3 as an example. The sums of rows, +columns and main diagonals of this square are all equal to 15. + +Write a C program to print magic squares of order (cid:0) + +(cid:16)(cid:18)(cid:16)(cid:18)(cid:16) + +(cid:6) . + +Revision: 6.37 + +(cid:15) +(cid:0) +(cid:14) +(cid:6) +(cid:15) +(cid:4) +(cid:0) +(cid:0) +(cid:6) +(cid:9) +(cid:2) +(cid:6) +(cid:2) +(cid:1) +(cid:14) +(cid:2) +(cid:14) +(cid:9) +(cid:0) + 180 + +Chapter5. Arrays + +Revision: 6.37 + + c(cid:0) + +1995,1996 Pieter Hartel & Henk Muller, all rights reserved. + +Chapter 6 + +Lists + +The preceding chapters discussed non-recursive data structures. Chapters 2 and 3 +used scalar data types such as int, double, bool, the enumerated types and +functions. Chapter 4 used non-recursive structures to build tuples and algebraic +data types using the C language elements struct and union. The resulting data +structures are strictly hierarchical. These data structures are characterised by their +simplicity and their in(cid:3)exibility: once de(cid:2)ned, the structure cannot be changed, +although the components of the structure can be given arbitrary values. + +Chapter 5 made a (cid:2)rst step towards a more (cid:3)exible data structure, the array. +An array was introduced as an implementation of a sequence. One of the major +problems with arrays is that they are expensive to extend and to contract. The list +provides an alternative implementation of a sequence. Lists are easy to extend and +contract, but lists also have disadvantages. The present chapter will see a develop- +ment of a recursive data type by discussing the list. We will also compare lists to +arrays. We are careful not to change the representation of data when moving from +the functional to the imperative domain. + +6.1 Lists of characters + +The list is one of the fundamental data types of functional programming. Sev- +eral examples have been discussed where a recursive algorithm operates on an +arithmetic sequence. Such a sequence is just a list of integers. So far, the C im- +plementations could be made without lists, mainly because arithmetic sequences +were represented in the C implementations as for-statements. However, there are +many problems that require (cid:3)exible data structures such as lists, so their C imple- +mentation will be discussed. To simplify the discussion, a list of characters will be +de(cid:2)ned and used in this chapter. In Chapter 8, the approach will be generalised to +polymorphic lists. + +All functional languages provide lists as primitives. It is also possible to de(cid:2)ne +a list explicitly. Here is the de(cid:2)nition in SML of an algebraic data type with two +constructors Nil and Cons, which is effectively a list: + +datatype char_list = Nil + +| Cons of (char * char_list) ; + +181 + + 182 + +Chapter6. Lists + +A list of two characters (cid:147)Hi(cid:148) can now be written as: + +(* list_hi : char_list *) +val list_hi = Cons("H",Cons("i",Nil)) ; + +In C, a list of characters is be de(cid:2)ned as shown below. + +typedef struct list_struct { + +char +struct list_struct * list_tail ; + +list_head ; + +} *char_list ; + +The char_list de(cid:2)nition uses the pointers of C to implement a list struc- +ture. The type char_list is a pointer to a structure with two (cid:2)elds. The +(cid:2)rst (cid:2)eld is called list_head and is of type char. The second (cid:2)eld of the list +structure has the name list_tail and is a pointer to something of the type +struct list_struct. This type refers back to the structure being de(cid:2)ned; it +is a recursive data type that we are de(cid:2)ning, so we should expect an element of +recursion in the de(cid:2)nition. + +Each de(cid:2)nition of a structure (or a union) may have an identi(cid:2)er, say +this_identifier, +immediately following the keyword struct. The pair +struct this_identifier can then be used to refer to the type. This is the only +construction that allows the de(cid:2)nition of a recursive type, because C does not al- +low the use of a type identi(cid:2)er that is not yet de(cid:2)ned. Hence, it would be illegal to +de(cid:2)ne the character list in terms of a char_list. + +In a functional program, storage allocation is automatic, but in a C program +data structures must be allocated explicitly. The logical place to put list structures +is on the heap. Here is a function cons that allocates a structure of the right size on +the heap and then (cid:2)lls in the appropriate (cid:2)elds of the structure. This is a typical, +idiomatic C function. + +#define list_struct_size sizeof( struct list_struct ) + +char_list cons( char head, char_list tail ) { +char_list l = malloc( list_struct_size ) ; +if( l == NULL ) { + +printf( "cons: no space\n" ) ; +abort( ) ; + +} +l->list_head = head ; +l->list_tail = tail ; +return l ; + +} + +The function malloc allocates space on the heap. +It works just like the func- +tion calloc discussed in Section 5.7, except that it allocates a block of mem- +ory just large enough to hold one value, +in this example of the size of a +list_struct. The contents of this cell are not initialised to 0 by malloc; in- +stead, the value of the cell is unde(cid:2)ned. +In this case, the size of the cell is +sizeof( struct list_struct ), which refers to the size of the structure + +Revision: 6.34 + + 6.1. Listsofcharacters + +183 + +list_struct. The two assignment statements initialise the head and tail (cid:2)elds +of the data structure. + +Every list must be properly terminated so that functions operating on a list can +(cid:2)nd out where the list ends. The C convention for indicating the end of any list +or recursive data structure is to use a null-pointer, denoted NULL. The SML value +list_hi shown above can be implemented in C as follows: + +char_list list_hi( void ) { +char_list hi = cons( (cid:146)H(cid:146), +return hi ; + +} + +cons( (cid:146)i(cid:146), + +NULL ) ) ; + +When executed, the function list_hi creates the heap structure shown below: + +hi: + +(cid:146)H(cid:146) + +(cid:146)i(cid:146) + +A box represents a data structure of type list_struct, and an arrow represents +pointer of type char_list. The local variable hi points at the (cid:2)rst cell of the list. +The null pointer that indicates the end of the list is shown as a (cid:1) ; it represents the +NULL value. + +6.1.1 List access functions: head and tail + +When accessing the elements of a list, it is convenient to have access functions for +the components of the structure. This gives rise to the following two SML func- +tions: + +(* head : char_list -> char *) +fun head (Cons(x,xs)) = x ; + +(* tail : char_list -> char_list *) +fun tail (Cons(x,xs)) = xs ; + +These functions are readily implemented in C: + +char head( char_list l ) { + +if( l == NULL ) { + +abort() ; + +} +return l->list_head ; + +} + +char_list tail( char_list l ) { + +if( l == NULL ) { + +abort() ; + +Revision: 6.34 + +(cid:1) + 184 + +} + +} +return l->list_tail ; + +Chapter6. Lists + +Often C programmers tend not to use functions for head and tail, but to inline the +code directly, using l->list_head and l->list_tail. For two reasons inlin- +ing is slightly more ef(cid:2)cient. Firstly, the function call overhead is avoided. Sec- +ondly, the test on the end of the list is avoided (l == NULL), which is safe if the +programmer ‘knows’ that the list is not empty, similar to avoiding bound checks +on arrays, see Chapter 5. The disadvantage of inlining is however that the struc- +ture of the data is exposed in several places in the program. It will be impossible +to hide implementation details, a feature which will be discussed in Chapter 8. +Therefore, it is better to leave inlining to the compiler. + +Exercise 6.1 Write a C procedure print_list to print the characters of a + +char_list as a string. Use a while-statement. + +Exercise 6.2 The SML data type char_list above represents an algebraic +data type, with recursive use of the type char_list. The C version +char_list shown above uses the conventional C notation NULL to denote +the end of the list, instead of using an equivalent of the SML equivalent +Nil. Show how the C constructs union, enum, and struct can be used to +create a literal equivalent in C of the algebraic data type char_list (see +also Chapter 4) + +The correspondence between a selection of useful list primitives as they appear +in functional languages and the newly de(cid:2)ned list functions and constants in C is +summarised below: + +function lang. SML type or C prototype +Cons + +SML char -> char_list -> char_list + +C + +char_list cons( char, char_list ) + +Nil + +SML char_list + +C + +char_list NULL + +head + +SML char_list -> char + +C + +char + +head( char_list ) + +tail + +SML char_list -> char_list + +C + +char_list tail( char_list ) + +The following sections will see a graded series of example problems that use lists. +This will create, amongst others, the implementations of the following functions: + +Revision: 6.34 + + 6.2. Thelengthofalist + +185 + +function lang. SML type or C prototype +length SML char_list -> int +int + +C + +length( char_list ) + +nth + +SML char_list -> int -> char + +C + +char + +nth( char_list, int ) + +append SML char_list -> char_list -> char_list + +C + +char_list append( char_list, char_list ) + +filter SML (char->bool) -> char_list -> char_list + +C + +char_list filter(bool (*pred)(char),char_list) + +map + +SML (char->char) -> char_list -> char_list + +C + +char_list map( char (*f)( char ), char_list ) + +6.2 The length of a list + +The basic list abstraction can be put to work in the implementation of a few recur- +sive list functions. The SML function length computes the length of a list, which +corresponds to (cid:8) + +(cid:3) on a sequence. + +(* length : char_list -> int *) +fun length Nil + += 0 + +| length (Cons(x,xs)) = 1 + length xs ; + +C has no pattern matching, so explicit calls to list access functions are required. +To prepare for the transition to C, the length function must be rewritten to use +access functions and a conditional instead of pattern matching: + +(* length : char_list -> int *) +fun length x_xs = if x_xs = Nil + +then 0 +else 1 + length (tail x_xs) ; + +The corresponding C implementation is now constructed using the basic tech- +nique from Chapter 2. + +int length( char_list x_xs ) { + +if ( x_xs == NULL ) { + +return 0 ; + +} else { + +return 1 + length( tail( x_xs ) ) ; + +} + +} + +Exercise 6.3 Write a tail recursive version of length in SML and give the corre- + +sponding C implementation that uses a while-statement. + +Revision: 6.34 + + 186 + +Chapter6. Lists + +6.3 Accessing an arbitrary element of a list + +Another useful function, nth, accesses an arbitrary element from a list. This cor- +responds to the access operator on sequences (cid:3) + +. + +(* nth : char_list -> int -> char *) +fun nth (Cons(x,xs)) 0 = x + +| nth (Cons(x,xs)) n = nth xs (n-1) ; + +The pattern matching can be removed from nth. This yields an SML-function that +can be directly implemented in C. + +(* nth : char_list -> int -> char *) +fun nth x_xs n = if n = 0 + +then head x_xs +else nth (tail x_xs) (n-1) ; + +The function nth is tail recursive; this makes it straightforward to use the while- +schema from Chapter 3: + +char nth( char_list x_xs, int n ) { + +while( n != 0 ) { + +x_xs = tail( x_xs ) ; +n-- ; + +} +return head( x_xs ) ; + +} + +Exercise 6.4 When trying to access a non-existent list element, the SML de(cid:2)nition +of nth raises the exception Match, but the C implementation of nth pro- +duces an unde(cid:2)ned result. Modify the C version of nth so that it aborts +with an error message when a non-existent list element is accessed. + +6.4 Append, (cid:2)lter and map: recursive versions + +The last three generally useful list processing functions, append, filter, and +map, are functions that are not tail recursive. It is possible to develop ef(cid:2)cient C +versions using a technique known as open lists. Below, we will (cid:2)rst discuss three +simple recursive (and inef(cid:2)cient) versions; the next section discusses the optimisa- +tion technique. + +6.4.1 Appending two lists + +The function append corresponds to concatenation of sequences. When given two +separate lists, it creates a new list from the concatenation of the two lists. + +The recursive SML de(cid:2)nition is: + +(* append : char_list -> char_list -> char_list *) +fun append Nil + +ys = ys + +| append (Cons(x,xs)) ys = Cons(x,append xs ys) ; + +Revision: 6.34 + +(cid:1) +(cid:3) +(cid:8) + 6.4. Append,(cid:2)lterandmap: recursiveversions + +187 + +Exercise 6.5 Rewrite the recursive de(cid:2)nition of append to use list primitives and + +conditionals rather than pattern matching. + +The function append can be translated into a recursive C equivalent as shown be- +low. How to create a version that uses a while-loop is discussed in Section 6.5: + +char_list append( char_list x_xs, char_list ys ) { + +if( x_xs == NULL ) { + +return ys ; + +} else { + +return cons( head( x_xs ), + +append( tail( x_xs ), ys ) ) ; + +} + +} + +When applied to the two argument lists, the append function copies the (cid:2)rst list +and puts a pointer to the second list at the end of the copy. The copying is nec- +essary, as append cannot be sure that the (cid:2)rst argument list is not going to be +needed again. To illustrate this important point, consider a concrete example of +using append. This is the function list_hi_ho below. It appends the two lists +hi and ho into the result list hiho. + +char_list list_hi_ho( void ) { + +char_list hi = cons( (cid:146)H(cid:146), +char_list ho = cons( (cid:146)H(cid:146), +char_list hiho = append( hi, ho ) ; +return hiho ; + +cons( (cid:146)i(cid:146), +cons( (cid:146)o(cid:146), + +} + +NULL ) ) ; +NULL ) ) ; + +Executing the function list_hi_ho creates the two heap structures shown be- +low: + +hiho: + +(cid:146)H(cid:146) + +hi: + +ho: + +(cid:146)i(cid:146) + +(cid:146)H(cid:146) + +(cid:146)H(cid:146) + +(cid:146)i(cid:146) + +(cid:146)o(cid:146) + +The local variables hi, ho, and hiho are each shown to point to the relevant +parts of the structures. The list pointed to by the variable hi has been copied by + +Revision: 6.34 + +(cid:1) +(cid:1) + 188 + +Chapter6. Lists + +append. The other list, pointed at by ho, is shared. The function list_hi_ho +returns the result list hiho. The list pointed at by hi is by then no longer accessi- +ble, the list pointed at by ho is accessible as part of the result list. The heap storage +for the inaccessible hi list can be reclaimed. The storage occupied by the ho list +cannot be reclaimed, because it is still accessible. In general, it is dif(cid:2)cult to de- +termine which heap structures will be redundant and which structures are still in +use. Consequently reusing heap data structures should be done with care. See also +Section 6.8. + +6.4.2 Filtering elements from a list + +Filtering is a generally useful operation over lists. When given a predicate pred +and an input list, the filter function selects only those elements for which the +predicate returns true: + +(* filter : (char->bool) -> char_list -> char_list *) +fun filter pred Nil + += Nil + +| filter pred (Cons(x,xs)) + += if pred(x) + +then Cons(x,filter pred xs) +else filter pred xs ; + +Exercise (cid:0) 6.6 Give the speci(cid:2)cation of filter in terms of sequences. + +The filter function can be written directly in C, using the techniques that have +been developed earlier in this chapter: + +char_list filter( bool (*pred)( char ), char_list x_xs ) { + +if ( x_xs == NULL ) { + +return NULL ; + +} else { + +char x = head( x_xs ) ; +char_list xs = tail( x_xs ) ; +if( pred( x ) ) { + +return cons( x, filter( pred, xs ) ) ; + +} else { + +return filter( pred, xs ) ; + +} + +} + +} + +Let us now use filter to select all digits from a list of characters. The SML ver- +sion is: + +(* filter_digit : char_list -> char_list *) +fun filter_digit xs = filter digit xs ; + +Revision: 6.34 + + 6.4. Append,(cid:2)lterandmap:recursiveversions + +189 + +The function filter_digit uses an auxiliary function digit as the predicate: + +(* digit : char -> bool *) +fun digit x = x >= "0" andalso x <= "9" ; + +A higher order function such as filter is a powerful abstraction. +It encapsu- +lates the full mechanism required to traverse the input list, whilst offering com- +plete freedom in the choice of an appropriate predicate. Instead of (cid:2)ltering out +digits, any other (type correct) predicate can be supplied as an argument to (cid:2)l- +ter. For the software engineer, abstractions such as filter are attractive, as they +allow one problem to be solved once and for all. Solutions to more complicated +problems can be built on that basis. + +In C, filter can be used for the same purpose, that is, to (cid:2)lter out elements + +from the list, such as digits or characters greater than the letter ’A’, and so on: + +char_list filter_digit( char_list xs ) { + +return filter( digit, xs ) ; + +} + +Here is the C version of digit: +bool digit( char x ) { + +return x >= (cid:146)0(cid:146) + +&& x <= (cid:146)9(cid:146) + +; + +} + +An interesting problem arises when the predicate needs some extra information. +Consider (cid:2)ltering out elements greater than a certain ‘pivot’ value p. The SML +code would be written like this: + +(* filter_greater : char -> char_list -> char_list *) +fun filter_greater p xs + += let + +in + +fun greater_p x = x > (p:char) + +filter greater_p xs + +end ; + +The pivot p is passed by greater_p directly to the operator >. The function +greater_p is a partially applied version of the comparison operator >, as it al- +ready knows which right operand to use, p. The use of a local function de(cid:2)nition +is essential here, since it encapsulates the value of p. If we were to lift the de(cid:2)ni- +tion of greater_p out of the let construct, the value of p would be unknown, +for it would be out of its de(cid:2)ning scope. + +In C, local function de(cid:2)nitions are not permitted. The solution to this prob- +lem, as discussed in Chapter 4, will be used here also. Instead of encapsulating +the pivot p in the local function de(cid:2)nition, as in the SML version, the C version +passes the pivot explicitly to a new version of filter with an extra argument. +Unfortunately, this means that the C version of filter has to be modi(cid:2)ed. The +modi(cid:2)cations consist of adding an extra argument arg to both filter and the +predicate pred: + +char_list extra_filter( bool (*pred)( void *, char ), + +void * arg, char_list x_xs ) { + +Revision: 6.34 + + 190 + +Chapter6. Lists + +if ( x_xs == NULL ) { + +return NULL ; + +} else { + +char x = head( x_xs ) ; +char_list xs = tail( x_xs ) ; +if( pred( arg, x ) ) { + +return cons( x, extra_filter( pred, arg, xs ) ) ; + +} else { + +return extra_filter( pred, arg, xs ) ; + +} + +} + +} + +The original C version of filter was not general enough. To see extra_filter +in action, consider again the problem of (cid:2)ltering out elements greater than the +pivot p from a list of characters. + +char_list filter_greater( char p, char_list xs ) { + +return extra_filter( greater, &p, xs ) ; + +} + +The address of the pivot p is passed as the second argument to extra_filter, +which in turn will pass it to the predicate greater. The latter dereferences its +pointer argument arg: + +bool greater( void *arg, char x ) { + +char * c = arg; +return x > *c ; + +} + +The function greater accesses the pivot value by dereferencing the pointer arg, +which points to the pivot value p. + +6.4.3 Mapping a function over a list + +Another powerful higher order abstraction of list operations is to map a function +over a list, that is, to apply a certain function f to all elements of a list. Here is the +SML version of map: + +(* map : (char->char) -> char_list -> char_list *) += Nil +fun map f Nil + +| map f (Cons(x,xs)) = Cons(f x,map f xs) ; + +Exercise (cid:0) 6.7 Give the speci(cid:2)cation of map in terms of sequences. + +Exercise (cid:0) 6.8 Prove that the SML-function map shown above satis(cid:2)es the speci(cid:2)- + +cation given in Exercise 6.7. + +Revision: 6.34 + + 6.5. Openlists + +191 + +The map function can be written directly in C: + +char_list map( char (*f)( char ), char_list x_xs ) { + +if( x_xs == NULL ) { + +return NULL ; + +} else { + +char x = head( x_xs ) ; +char_list xs = tail( x_xs ) ; +return cons( f( x ), map( f, xs ) ) ; + +} + +} + +Exercise 6.9 Generalise map to extra_map in the same way as filter has been + +generalised to extra_filter. + +This concludes the (cid:2)rst encounter of lists in C. The primitives append, map, +extra_map, filter, and extra_filter may be inef(cid:2)cient still. This issue +will be revisited in the next section. All implementations are modular, so they +would be appropriate building blocks for many list processing applications in C +programs. + +6.5 Open lists + +The conceptually simple operation of making a copy of a list is surprisingly dif(cid:2)- +cult to implement ef(cid:2)ciently. In this section, a list copy function will be discussed +to illustrate a useful optimisation technique that can be applied in a C implemen- +tation but not in the (pure) functional world. An SML function to copy a list is: + +(* copy : char_list -> char_list *) +fun copy Nil + += Nil + +| copy (Cons(x,xs)) = Cons(x,copy xs) ; + +After rewriting this function without pattern matching, a recursive C implementa- +tion can be derived using the while-schema: + +char_list copy( char_list x_xs ) { + +if( x_xs == NULL ) { + +return NULL ; + +} else { + +return cons( head( x_xs ), copy( tail( x_xs ) ) ) ; + +} + +} + +Although this implementation is ef(cid:2)cient in time (the list copy will take a time +proportional to the length of the list), the implementation is not tail recursive. This +means that the implementation requires stack space proportional to the length of +the list, which is undesirable. + +Revision: 6.34 + + 192 + +Chapter6. Lists + +The technique available for turning a non-tail recursive function into a tail re- +cursive one reverses the sequence of events. In this case, it would mean one of two +possibilities: + +(cid:1) To traverse the list x_xs from right to left and to build the result list up from + +right to left + +(cid:1) To traverse and construct from left to right. + +Both options go against the (cid:3)ow of one list in order to go with the (cid:3)ow of the other. +Here is the (cid:2)rst solution: + +(* copy(cid:146) : char_list -> char_list -> char_list *) +fun copy(cid:146) accu Nil + += accu + +| copy(cid:146) accu (Cons(x,xs)) + += copy(cid:146) (append accu (Cons(x,Nil))) xs ; + +(* copy : char_list -> char_list *) +fun copy xs = copy(cid:146) Nil xs ; + +(cid:16)(cid:18)(cid:16)(cid:18)(cid:16) + +(cid:15)2(cid:1)1(cid:15) + +The tail-recursive function copy(cid:146) uses an accumulating argument to assemble the +result list while traversing the input list. Each new input element is attached at +the end of the result list using append. This makes copy(cid:146) +inef(cid:2)cient, because it +If the +creates a completely new list for every element of the original input list. +elements, the total number of Cons cells created is (cid:0) +input list contains +(cid:6) . Thus by writing a tail recursive function, we have made +the problem worse rather than better. Why then have we then gone through all +this trouble? The answer is that the calls to append are not really necessary. With +some programming effort, we can improve the tail recursive version of copy such +Cons cells, whilst still being tail recursive. The solution +that it will only allocate +that we will obtain is ef(cid:2)cient, as it does precisely the amount of work that one +would expect, using only a constant amount of stack space. However, there is a (cid:3)y +in the ointment: the ef(cid:2)cient solution cannot be programmed in SML. Fortunately +it can be written nicely in C. + +Exercise 6.10 Write a version of copy that traverses the input list from the right, + +using foldr. Then translate the result into C. + +Consider the following append based C implementation of the tail recursive ver- +sion of copy: + +char_list copy( char_list xs ) { + +char_list accu = NULL ; +while( xs != NULL ) { + +accu = append( accu, cons( head( xs ), NULL ) ) ; +xs = tail( xs ) ; + +} +return accu ; + +} + +Revision: 6.34 + +(cid:15) +(cid:2) +(cid:6) +(cid:2) +(cid:2) +(cid:2) +(cid:15) +(cid:0) +(cid:2) +(cid:0) +(cid:8) +(cid:1) +(cid:15) + 6.5. Openlists + +193 + +This implementation is inef(cid:2)cient because of the use of the append function. +When we discussed the append function earlier it was noted that append has +to copy its (cid:2)rst argument, so that the (pointer to) the second argument can be at- +tached at the end of the copy. We stated that this is necessary because, in general, +one does not know whether the (cid:2)rst argument is shared. It is not safe to change +a potentially shared argument. However, in this case, we do know that the (cid:2)rst +argument accu of append is not shared. + +Inspecting the code of copy above, we see that initially the accumulator rep- +resents the empty list. Appending a new list to the empty list merely returns the +new list; therefore, the second time around the while loop, the (cid:2)rst argument to +append is the list that was created during the (cid:2)rst round. Therefore, this list is +not shared, and it is safe to change it. The same reasoning applies to subsequent +iterations, so that throughout the execution of the while loop, we can be sure that +the (cid:2)rst argument of append is always a list that is not shared. Thus, it can be +changed safely. + +The ef(cid:2)cient version of our list copy problem uses this information by applying +the following open list technique: by remembering where the previous iteration +has appended an element, the next element can be appended at that point, without +requiring further list traversal. The name ‘open list’ stems from the fact that at +each stage, the result list is still open ended, as more elements are yet to be added +to the right. + +There are two ways to remember this last element, but neither exist in the func- +tional world. The (cid:2)rst method is relatively clean, but requires some code duplica- +tion. The second method is less clear, but more ef(cid:2)cient. Both methods are used in +real C programs, so they are discussed below. + +6.5.1 Open lists by remembering the last cell + +A relatively clean way to complete the implementation of the list copy function +is to remember where the last element has been appended to the output list. To +do this, there must be a cell that can be identi(cid:2)ed with the last element. The +copy function will now be completed in three steps. As the (cid:2)rst step, the while- +statement will be unrolled once. A while-statement can always be unrolled based +on the following observation: + +while( condition ) { + +statement ; + +} + +if( condition ) { + +statement ; +while( condition ) { + +statement ; + +} + +} + +The result of unrolling is that the (cid:2)rst iteration of the loop is executed before the +while. The statements of the (cid:2)rst iteration, now separate from the statements +of subsequent iterations, can be optimised using the knowledge that all variables +have their initial values. This information will help to create an ef(cid:2)cient function. + +Revision: 6.34 + +(cid:0) + 194 + +Chapter6. Lists + +The while-statement in copy above can be unrolled, yielding the following +function. It looks complicated because of the code duplication, but these compli- +cations will be optimised away shortly: + +char_list copy( char_list xs ) { + +char_list accu = NULL ; +if( xs != NULL ) { + +accu = append( accu, cons( head( xs ), NULL ) ) ; +xs = tail( xs ) ; +while( xs != NULL ) { + +accu = append( accu, cons( head( xs ), NULL ) ) ; +xs = tail( xs ) ; + +} + +} +return accu ; + +} + +The second step towards a solution is to look closely at the fourth line where the +(cid:2)rst of the two assignments is done: + +accu = append( accu, cons( head( xs ), NULL ) ) ; + +At this point, the list accu is guaranteed to be NULL. Thus the statement at line 4 +may safely be replaced by: + +accu = cons( head( xs ), NULL ) ; + +This removes the (cid:2)rst use of append. To remove the second use of append, the +third and (cid:2)nal step introduces a new variable last which remembers where the +last element has been attached to the result list: +char_list copy( char_list xs ) { + +char_list accu = NULL ; +char_list last ; +if( xs != NULL ) { + +last = accu + += cons( head( xs ), NULL ) ; + +xs = tail( xs ) ; +while( xs != NULL ) { + +last = last->list_tail + += cons( head( xs ), NULL ) ; + +xs = tail( xs ) ; + +} + +} +return accu ; + +} + +Here, we are using a convenient shorthand available in C for assigning the same +value to several variables at once: + +last = accu + += cons( head( xs ), NULL ) ; + +Revision: 6.34 + + 6.5. Openlists + +195 + +The statement above has exactly the same meaning as the two statements below, +because the second assignment is used as an expression (explained in Chapter 3): + +accu = cons( head( xs ), NULL ) ; +last = accu ; + +To illustrate the working of the open list based function copy, consider the follow- +ing C function: + +char_list list_ho( void ) { +char_list ho = cons( (cid:146)H(cid:146), +char_list copy_ho = copy( ho ) ; +return copy_ho ; + +cons( (cid:146)o(cid:146), + +NULL ) ) ; + +} + +The list ho is created (cid:2)rst: + +ho: + +(cid:146)H(cid:146) + +(cid:146)o(cid:146) + +After creation, the list is copied to copy_ho. The (cid:2)rst step makes a copy of the +(cid:2)rst list_struct cell: + +accu: + +last: + +(cid:146)H(cid:146) + +The next step remembers, through the use of the variable last, where the previ- +ous step has put its data and attaches the copy of the next cell at this point: + +accu: + +last: + +(cid:146)H(cid:146) + +(cid:146)o(cid:146) + +The resulting C implementation is perhaps a bit complicated but it is ef(cid:2)cient. The +price one often has to pay for ef(cid:2)ciency is loss of clarity and conciseness. As a +general rule, this is acceptable provided a relatively complex function has a well +de(cid:2)ned and clean interface so that it can be used without much knowledge of its +internals. Clearly, this is the case with the list copying function. + +6.5.2 Open lists by using pointers to pointers + +The (cid:2)rst method to complete the copy function from the previous section remem- +bers a pointer to the last cell added. In this section, we describe another method. + +Revision: 6.34 + +(cid:1) +(cid:1) +(cid:1) + 196 + +Chapter6. Lists + +It uses a pointer that remembers which pointer to overwrite in order to append +the next cell. This is a more advanced use of pointers and results in a concise and +idiomatic C function. The complete solution is shown below; let us consider the +relevant aspects of the solution. The type of the variable last that remembers +which (cid:2)eld to overwrite is char_list *: it points to a pointer in the result list. +This result list is constructed starting from accu. Thus the pointer last initially +points at accu. Subsequently, last will refer to the tail (cid:2)eld of the last cell of +the result list. The address-of operator & is instrumental here. + +char_list copy( char_list xs ) { + +char_list accu = NULL ; +char_list *last = &accu ; +while( xs != NULL ) { + +char_list new = cons( head( xs ), NULL ) ; +*last = new ; +last = &new->list_tail ; +xs = tail( xs ) ; + +} +return accu ; + +} + +To help understand how the above function copy works, consider the diagrams +It shows three stages of the process of copying the list produced by +below. +. Initially the result list is empty, and accu con- +cons((cid:146)H(cid:146),cons((cid:146)o(cid:146),NULL)) +tains a NULL pointer. At this stage last points to accu: + +accu: + +last: + +The (cid:2)rst assignment statement of the while-statement then creates a new cons +cell, and the second assignment-statement stores this pointer via *last at the end +of the list, which is initially in accu. The third statement then updates last so +that it points to the new tail of the list, the element tail_list of the new node. +The states of accu and last are shown graphically below: + +accu: + +last: + +(cid:146)H(cid:146) + +The next iteration creates a new cell (cid:146)o(cid:146) +and uses last to place the new cell at the +end of the list. The variable last is updated to point to the end of the list again, +which results in the following state: + +Revision: 6.34 + +(cid:1) +(cid:1) + 6.5. Openlists + +197 + +accu: + +last: + +(cid:146)H(cid:146) + +(cid:146)o(cid:146) + +This is the last iteration of the loop, so the function returns the newly created list. +This completes the description of two ef(cid:2)cient implementations of copy based +on open lists. These two implementations are functionally identical (as they are +identical to the naive implementation that would use a call to append). The im- +plementations are also good building blocks: The internals of the two implemen- +tations may be non-functional, but the functions provide a clean interface to their +callers without side effects. + +6.5.3 Append using open lists + +When the append function was introduced earlier in this chapter, we noted that +the ef(cid:2)ciency could still be improved by making the function tail recursive. The +structure of append is similar to that of copy. Here is a comparison between the +two: + +fun append Nil ys + += ys + +fun copy Nil += Nil + +| append (Cons(x,xs)) ys + +| copy (Cons(x,xs)) + += Cons(x,append xs ys) ; + += Cons(x,copy xs) ; + +The differences between copy and append are few: + +Argument: append has an extra argument ys. + +End of input: where copy returns the empty list Nil, append returns its extra + +argument list ys. + +Therefore, taking the ef(cid:2)cient loop-based C implementation of copy from Sec- +tion 6.5.1 and making changes corresponding to the differences noted above +should give an ef(cid:2)cient C implementation of append. Here is the result, anno- +tated with the changes: + +char_list append( char_list xs, + +char_list ys ) { + +char_list accu = ys; +char_list last ; +if( xs != NULL ) { + +last = accu + +/*added char_list ys*/ +/*replaced NULL by ys*/ + += cons( head(xs), ys ) ; + +/*replaced NULL by ys*/ + +xs = tail( xs ) ; +while( xs != NULL ) { + +Revision: 6.34 + +(cid:1) + 198 + +Chapter6. Lists + +last = last->list_tail + += cons( head(xs), ys ) ; /*replaced NULL by ys*/ + +xs = tail( xs ) ; + +} + +} +return accu ; + +} + +Programming with open lists can be rewarding if the functions are derived in a +systematic fashion. However, it is easy to make mistakes, so care should be taken +when using this technique. + +Exercise 6.11 Write a version of append that uses the advanced pointer technique + +for open lists from Section 6.5.2. + +Exercise 6.12 Page 191 shows a recursive version of map. Implement a version of + +map that uses open lists. + +Exercise 6.13 Page 188 shows a recursive version of filter. Implement a version + +of filter that uses open lists. + +6.6 Lists versus arrays + +The previous chapter discussed the array and, in this chapter, we have introduced +lists. From a mathematical point of view, arrays and lists are the same. Both repre- +sent a sequence, that is, an ordered set of elements. From an algorithmic point of +view, there are differences. The table below gives the cost of each of the ‘abstract’ +operations that can be performed on a sequence of + +elements. + +operation + +representation +list + +array + +(cid:1)(cid:13)(cid:15)3(cid:8) + +(cid:1)(cid:13)(cid:15)(cid:17)(cid:8) + +elements + +create a sequence of +extend with new (cid:2)rst element +extend with new arbitrary element +remove (cid:2)rst element +remove arbitrary element +access (cid:2)rst element +access arbitrary element + +(cid:1)(cid:13)(cid:15)3(cid:8) + +(cid:1)1(cid:15)3(cid:8) + +(cid:1)(cid:13)(cid:15)(cid:17)(cid:8) + +(cid:1)(cid:13)(cid:15)3(cid:8) + +(cid:1)1(cid:15)3(cid:8) + +(cid:1)(cid:13)(cid:15)(cid:17)(cid:8) + +(cid:1)1(cid:15)3(cid:8) + +As an example, the last entry in the table ‘access arbitrary element’ states that a +list requires an amount of work proportional to +, whereas an array can deliver an +arbitrary element in constant time. To illustrate this point, consider the C function +list_array below: + +void list_array( void ) { + +char_list list = cons((cid:146)H(cid:146),cons((cid:146)i(cid:146), + +cons((cid:146)H(cid:146),cons((cid:146)o(cid:146),NULL)))) + +; + +char array[4] = {(cid:146)H(cid:146),(cid:146)i(cid:146),(cid:146)H(cid:146),(cid:146)o(cid:146)}; + +} + +Revision: 6.34 + +(cid:15) +(cid:15) +(cid:0) +(cid:0) +(cid:0) +(cid:1) +(cid:0) +(cid:8) +(cid:0) +(cid:0) +(cid:0) +(cid:0) +(cid:1) +(cid:0) +(cid:8) +(cid:0) +(cid:0) +(cid:0) +(cid:0) +(cid:1) +(cid:0) +(cid:8) +(cid:0) +(cid:1) +(cid:0) +(cid:8) +(cid:0) +(cid:0) +(cid:1) +(cid:0) +(cid:8) +(cid:15) + 6.6. Listsversusarrays + +199 + +The store arrangement for the data structures allocated for list and array are: + +list: + +(cid:146)H(cid:146) + +array: + +(cid:146)H(cid:146) + +(cid:146)i(cid:146) + +(cid:146)H(cid:146) + +(cid:146)o(cid:146) + +(cid:146)i(cid:146) + +(cid:146)H(cid:146) + +(cid:146)o(cid:146) + +The array is stored as a contiguous block. Therefore the array requires less space, +because no pointers are necessary to connect the elements of the data structure, as +for lists. More importantly, it is possible to calculate offsets from the beginning of +the array and to use these offsets to access an arbitrary element directly. On the +other hand the fact that a list is not stored as a contiguous block, but as a chain of +blocks, makes it inexpensive to attach a new element to the front of the list. An +array would have to be copied in order to achieve the same effect. + +In designing algorithms that operate on a sequence, the appropriate data rep- +resentation must be selected. Depending on the relative importance of the various +operations, the list or the array will be more appropriate. There are other data +structures that may be used to represent a sequence, such as streams, queues, and +trees. These will have different characteristics and may therefore be more appro- +priate to some applications. Streams are discussed in Chapter 7 and trees are the +subject of a number exercises at the end of this chapter. A discussion of the more +advanced data structures can be found in a book on algorithms and data struc- +tures, such as Sedgewick [12]. + +6.6.1 Converting an array to a list + +To study the difference between an array and a list more closely, we consider the +problem of transferring the contents of an array into a list and the conversion from +a list into an array. As before, the elements of both data structures will be charac- +ters to simplify the presentation. + +The following SML program converts an array to a list. It (cid:2)rst creates a list of +all possible index values of the array and then accesses each array element using +the appropriate index value. + +(* array_to_list : char array -> char_list *) +fun array_to_list s + += let + +in + +val l = 0 +val u = length s - 1 +fun subscript i = sub(s, i) + +map subscript (l--u) + +Revision: 6.34 + +(cid:1) + 200 + +end ; + +Chapter6. Lists + +The lower bound of the array s is l=0, and the upper bound is u=length s - 1. +Thus, the range of possible index values is l . . . u. + +The function array_to_list is inef(cid:2)cient for several reasons. Firstly, it cre- +ates the list of index values as an intermediate data structure, which is created and +then discarded. Secondly, it uses the non-tail recursive function map, which causes +the solution to require an amount of stack space proportional to the length of the +array. + +There are alternative solutions that do not suffer from these problems. To avoid +the intermediate list, one could write a directly recursive solution. This will be +left as an exercise. We will explore a second alternative that yields the optimal +ef(cid:2)ciency. + +Exercise 6.14 Rewrite array_to_list as a non-tail recursive function and trans- + +late the result into a recursive C function. + +iterative version of the function array_to_list, the +To create an ef(cid:2)cient, +for-schema is needed, because an expression of the form (l -- u) must be +translated. However, the for-schema cannot be applied directly to the function +array_to_list, because it does not contain an application of either foldl or +foldr; it uses map instead. There is a formal relationship between foldr and +map that will be of use to us. Here is a reminder of what map and foldr accom- +plish on a list (of three elements to keep the example simple). Here f is a unary +function, and (cid:0) + +is a binary operator such that (cid:8) + +(cid:3) . + +(cid:9)(cid:0) + +(cid:0)(cid:10)(cid:8) + +map (cid:0) + +(cid:8)(cid:10)(cid:2) + +(cid:0)(cid:3)(cid:2) + +(cid:0)(cid:3)(cid:2) + +(cid:8)(cid:10)(cid:2) + +(cid:0)(cid:3)(cid:2) + +foldr (cid:0) + +The relationship illustrated above is when given that (cid:8) +have: + +(cid:0)(cid:3)(cid:2) + +-(cid:0) + +then we + +map (cid:0) + +foldr (cid:0) + +(cid:0)(cid:3)(cid:2) + +(6.1) + +Exercise (cid:0) 6.15 Prove (6.1) for (cid:2)nite lists by induction over the length of the list + +xs. + +Using (6.1) the SML function array_to_list is transformed to: +(* array_to_list : char array -> char_list *) +fun array_to_list s + += let + +val l = 0 +val u = length s - 1 + +Revision: 6.34 + +(cid:0) +(cid:2) +(cid:3) +(cid:0) +(cid:0) +(cid:2) +(cid:1) +(cid:0) +(cid:0) +(cid:1) +(cid:8) +(cid:0) +(cid:0) +(cid:0) +(cid:1) +(cid:8) +(cid:5) +(cid:0) +(cid:0) +(cid:8) +(cid:8) +(cid:8) +(cid:0) +(cid:0) +(cid:0) +(cid:0) +(cid:0) +(cid:0) +(cid:0) +(cid:1) +(cid:0) +(cid:8) +(cid:2) +(cid:0) +(cid:0) +(cid:1) +(cid:0) +(cid:8) +(cid:0) +(cid:0) +(cid:0) +(cid:1) +(cid:0) +(cid:8) +(cid:5) +(cid:0) +(cid:0) +(cid:8) +(cid:8) +(cid:8) +(cid:0) +(cid:29) +(cid:29) +(cid:29) +(cid:29) +(cid:29) +(cid:29) +(cid:29) +(cid:1) +(cid:0) +(cid:1) +(cid:8) +(cid:0) +(cid:0) +(cid:1) +(cid:8) +(cid:5) +(cid:0) +(cid:8) +(cid:8) +(cid:8) +(cid:0) +(cid:0) +(cid:0) +(cid:0) +(cid:0) +(cid:0) +(cid:0) +(cid:0) +(cid:2) +(cid:1) +(cid:8) +(cid:2) +(cid:0) +(cid:0) +(cid:1) +(cid:8) +(cid:0) +(cid:0) +(cid:0) +(cid:1) +(cid:8) +(cid:5) +(cid:0) +(cid:0) +(cid:8) +(cid:8) +(cid:8) +(cid:0) +(cid:2) +(cid:3) +(cid:0) +(cid:0) +(cid:8) +(cid:0) +(cid:2) +(cid:3) +(cid:8) +(cid:3) +(cid:0) +(cid:8) +(cid:3) + 6.6. Lists versusarrays + +201 + +fun sub_cons i xs = Cons(sub(s, i), xs) + +in + +foldr sub_cons Nil (l -- u) + +end ; + +The right folding decreasing for-schema yields the C function: +char_list array_to_list( char s [], int n ) { + +int l = 0 ; +int u = n - 1 ; +char_list list = NULL ; +int i ; +for( i = u; i >= l; i-- ) { + +list = cons( s[i], list ) ; + +} +return list; + +} + +The C function array_to_list ef(cid:2)ciently transfers the contents of an array of +characters into a list of characters. The reason why an ef(cid:2)cient for-loop based ver- +sion could be developed is because the cost of indexing an arbitrary element of the +array is (cid:0) +. Thus, accessing the elements of the array from left to right or from +right to left is immaterial. In the next chapter, similar examples will appear that do +not have this property. In one of these examples, text will be read from a stream, +which must happen strictly from left to right. The consequences of this seemingly +innocuous property will be far reaching. + +6.6.2 From a list to an array + +The dual problem of transferring an array into a list is creating an array from a list. +This is what the foldl based SML function below achieves: + +(* list_to_array : char_list -> char array *) +fun list_to_array xs + += let + +in + +val n = length xs +val u = n - 1 +val s = array(n, " ") +fun update s i = upd(s,i,nth xs i) + +foldl update s (0 -- u) + +end ; + +The function list_to_array starts by creating a new array s of the right +size. The lower bound of the array is assumed to be 0; the upper bound u +is then one less than the length n of the list xs. Subsequently, the expression +foldl update s (0 -- u) runs trough the permissible index range, calling +upon the auxiliary function update to (cid:2)rst access the required elements from the +list xs and then to update the array s. The new values are obtained by indexing +the list using the list index function nth. + +Revision: 6.34 + +(cid:1) +(cid:0) +(cid:8) + 202 + +Chapter6. Lists + +The foldl version of the function array_to_list can be transformed di- +rectly into a C implementation by the for-schema. After simpli(cid:2)cation, the result +is: + +char * list_to_array( char_list xs ) { + +int n = length( xs ) ; +char * array = malloc( n ) ; +int i; +if( array == NULL ) { + +printf( "list_to_array: no space\n" ) ; +abort( ) ; + +} +for( i = 0; i < n; i++ ) { + +array[i] = nth( xs, i ) ; + +} +return array; + +} + +The implementation of list_to_array is not ef(cid:2)cient. The reason is that the +nth function accesses an arbitrary element. This is an (cid:0) +operation on a list +(see the table on page 198). For each element of the list xs, the nth function must +start again at the beginning, counting list elements until it has reached the desired +element. This is wasteful, as list_to_array traverses the list sequentially from +left to right. However, it should be possible to remember which point the previous +iteration of the for-loop has reached, so that the current iteration can access the +next list element. + +(cid:1)1(cid:15)3(cid:8) + +A new version of list_to_array can be written based on this idea. It has a +different structure because the index range and the list of values must be traversed +simultaneously. The new version could have been written in a ‘fold’ form as be- +fore, but not without some complications. The explicit recursive variant is more +appropriate in SML: + +(* list_to_array : char_list -> char array *) +fun list_to_array xs + += let + +val n = length xs +val s = array(n, " ") +fun traverse s i Nil + += s + +| traverse s i (Cons(x,xs)) + += traverse (upd(s,i,x)) (i+1) xs + +in + +traverse s 0 xs + +end ; + +The explicitly recursive variant of list_to_array above creates a fresh array +like its predecessors. It then calls upon the auxiliary function traverse to tra- +verse the index range and the list of values simultaneously. Each recursive invo- +cation of the auxiliary function causes the array s to be updated with a new value. + +Revision: 6.34 + + 6.6. Lists versusarrays + +203 + +The explicitly recursive form of the new list_to_array allows for the mul- +tiple argument while-schema to be applied. After simpli(cid:2)cation, this yields the +following C function: + +char * list_to_array( char_list xs ) { + +int n = length( xs ) ; +char * array = malloc( n ) ; +int i = 0 ; +if( array == NULL ) { + +printf( "list_to_array: no space\n" ) ; +abort( ) ; + +} +while( xs != NULL ) { + +array[i] = head( xs ) ; +i = i+1 ; +xs = tail( xs ) ; + +} +return array; + +} + +For each iteration, both the index i range and the list of values xs are advanced. + +The C function list_to_array ef(cid:2)ciently transfers the contents of a list of +characters into an array of characters because the list is traversed from left to right. +At each step the head and the tail of a list are accessed, these are both ef(cid:2)cient +operations ( (cid:0) + +). + +The moral of the story is that it is a good idea to ‘go with the (cid:3)ow’. If a data +structure supports some operations more ef(cid:2)ciently than others, one should use +the ef(cid:2)cient ones. In the case of lists, this means a traversal from left is preferred +above a traversal from the right. + +Exercise 6.16 C implements a string as an array of characters. + +Implement a +new string data type and a library of functions that represent a string as +Implement functions for stringcat, stringcmp, +a list of characters. +stringncmp, and stringlen. Also provide functions to convert between +array and list based strings. Can you store the (cid:146)\0(cid:146) +character in the list +based string? + +Exercise 6.17 Storing a single character in each cons cell makes the list of charac- +ters representation uneconomical in terms of its space usage. Reimplement +the string library so that it uses a list of arrays, using the following C data +structure: + +typedef struct string { + +char data[ 32 ] ; +int length ; +struct string *next ; + +} *string ; + +Revision: 6.34 + +(cid:1) +(cid:0) +(cid:8) + 204 + +Chapter6. Lists + +Each cell can store up to 32 characters, the number of characters stored in a +cell is speci(cid:2)ed in the length (cid:2)eld. Strings of more than 32 characters are +stored in cells that are linked via their next (cid:2)elds. + +6.7 Variable number of arguments + +It is sometimes useful to be able to write a single function that can be applied to a +variable number of arguments. Good examples of such functions are printf and +scanf. + +In SML and other functional languages, there are two ways to write such func- +tions. +If all arguments have the same type, they can be collected in a list, and +passed to the function. If the arguments have different types, an Algebraic Data +Type can be used to de(cid:2)ne which combinations of types are legal, and used to pass +the arguments. (This in addition to overloaded functions, which we will not discuss +here.) As an example, the standard function sum computes the sum of a series of +numbers, which are passed in a list. + +The same solution could be used in C, but since C does not have the syntax to +support easy creation and matching of lists and algebraic data types, this strategy +results almost always in unreadable programs. To allow the programmer to pass +a variable number of arguments, C has a built-in mechanism for variable arguments +lists, also known as vararg lists. + +The concept of a variable argument list in C is simple. Instead of specifying +the arguments precisely in a prototype, one must specify them with the ellipsis +notation ..., which stands for ‘any additional arguments of unspeci(cid:2)ed type’. +Thus, the prototype of a function sum that would add a certain number n of values +would read: + +int sum( int n, ... ) ; + +After this declaration, the following calls are legal: + +sum( 3, 5, 1, 9 ) == 15 +sum( 2, 314, 52 ) == 366 +sum( 0 ) == 0 + +&& +&& + +The ... notation in the prototype allows the programmer to indicate that any +number of arguments may be passed to this function. To use these arguments, +the function call must specify how many actual arguments there are and the func- +tion de(cid:2)nition must be written such that the arguments can be retrieved from the +argument list. Arguments are retrieved one at the time via an argument list pointer +and using three functions that operate on this pointer. + +The type of the argument list pointer is va_list, which stands for variable ar- +gument list. This type is declared in the include (cid:2)le stdarg.h. A variable of type +va_list must be initialised with a call to va_start. Successive elements can be +retrieved with calls to va_arg, while the function must end with a call to va_end. +As an example of its use, the function sum is de(cid:2)ned below with a variable argu- +ment list: + +#include + +Revision: 6.34 + + 6.7. Variablenumberofarguments + +205 + +int sum( int n, ... ) { + +int i, a ; +int accu = 0 ; +va_list arguments ; +va_start( arguments, n ) ; +for( i=0 ; i char *) +fun head (Cons(x,xs)) = x ; + +Firstly, the head function needs to analyse its argument so as to check that +it is of the form Cons(...,...) and not of the form Nil. Secondly, the +head function has to bind the value of the (cid:2)rst component of the Cons con- +structor to the variable x. It then also binds the value of the second compo- +nent to the variable xs, even though the latter is not used on the right hand +side of the de(cid:2)nition of head. Our task is to provide support in C for these +two activities: case analysis and binding. + +(a) Study the following two type de(cid:2)nitions carefully and relate the vari- +ous elements of the de(cid:2)nitions to the two activities identi(cid:2)ed above. + +typedef enum { Bind, Data } tree_tag ; + +typedef struct tree_struct { + +tree_tag tag ; +union { + +struct tree_struct ** bind ; +struct data_struct { + +/* Bind */ +/* Data */ +/* Data */ +char key ; +int size ; +/* Data */ +struct tree_struct ** data ; /* Data */ +/* Data */ + +} comp ; + +} alt ; + +} * tree_ptr ; + +(b) Write two functions mkBind and mkData to allocate the appropriate +version of the tree_struct on the heap. Use the vararg facility so + +Revision: 6.34 + + 212 + +Chapter6. Lists + +that the function takes an arbitrary number (possibly zero) of sub trees, +and calloc to allocate suf(cid:2)cient memory to hold the pointers to the +sub trees. The required prototypes of the functions are shown below. + +tree_ptr mkBind( tree_ptr * b ) ; +tree_ptr mkData( char k, int s, ... ) ; + +(c) Write a function match with the prototype given below: + +bool match( tree_ptr pat, tree_ptr exp ) ; + +The function should compare the two trees and return true if they +match, false otherwise. Two trees pat and exp match if: + +(cid:1) Both have tag Data and if both have the same key and size. In + +addition, all subtrees must match. +If the argument pat has tag Bind. +In that case, the (cid:2)eld bind +should be set to remember the value of exp. You may assume that +there are no nodes with tag Bind in the trees offered as the second +argument to match. + +(d) Write a main function to create some sample patterns and expressions + +to test your match function. + +Revision: 6.34 + +(cid:1) + c(cid:0) + +1995,1996 Pieter Hartel & Henk Muller, all rights reserved. + +Chapter 7 + +Streams + +The previous chapters discussed two data structures for storing sequences of data +items: lists and arrays. A third kind of sequence is the stream. An example of a +stream is the sequence of characters being typed by the user as input to a program, +or conversely, the characters being printed on the screen. + +In this chapter, streams are discussed, and they are compared with the two + +other sequences. A stream has two distinguishing features: + +(cid:1) A stream can only be accessed sequentially. That is, after accessing element +is needed + +(cid:2) can be accessed. If (cid:8) + +(cid:8) of the stream, only the next element (cid:8) +later on, it must be remembered explicitly. + +(cid:1) The number of items in a stream is not known beforehand. At any moment, + +the stream might dry up. + +In C and SML streams work by side effects. That is, reading a character from +a stream uses a function that returns a character (the result), and updates +some state to record that this character has been read. Writing a character +deposits the character on the stream, and updates some state to record this. + +In a functional language, a stream is sometimes captured via a list abstraction. +That is, a certain list does not have a predetermined value, but contains all charac- +ters that come from the stream. When the stream ends, the list is terminated (with +[]). Using a list is slightly deceptive, as it ‘remembers’ all previous characters in +the stream. + +Most programming languages, including C and SML, offer a set of low level +primitives that allow a program to open a certain stream, access the elements of +the stream sequentially, and then (cid:2)nally close the stream. The elements cannot +be accessed in an arbitrary order, as is the case with other sequences. Should the +programmer wish to use the elements of a stream in a different order than sequen- +tially, or should the programmer wish to use them more than once, the elements +of the stream must be stored for later use. Streams can be large, so it is often im- +practical to keep the entire contents of a stream in the store. The main issue in this +chapter is how to access a stream such that the least amount of store is needed to +remember stream elements. + +213 + +(cid:8) +(cid:8) +(cid:1) +(cid:8) +(cid:1) + 214 + +Chapter7. Streams + +As an example of the use of streams, four programs will be developed. The +(cid:2)rst program counts the number of sentences in a stream. A straightforward ver- +sion of this program remembers the entire stream. An optimised version of the +program will remember just one element of the stream. The second program will +calculate the average length of sentences in a stream. This program also comes in +two versions, one that remembers the entire stream and the other that remembers +only a single element. The third program counts the number of times a certain +word appears in a stream. This program needs to remember a number of elements +from the stream, where the number of elements is determined by the length of the +word. The last program will sort the elements of a stream. This program must +remember all elements of the stream. + +7.1 Counting sentences: stream basics + +We will now write a program to count the number of sentences in a text. The so- +lution has two aspects. The (cid:2)rst is how to de(cid:2)ne a sentence. We will assume that +a sentence is a sequence of characters that ends with a full stop. The number of +sentences will be taken as the number of full stop characters (cid:146).(cid:146) + +in the text: + +(cid:1).(cid:2) + +(cid:8)(cid:11)(cid:10) + +sentence count + +sentence count + +(cid:27) domain + +(7.1) + +As a (cid:2)rst solution, we can use two functions. One function captures the stream in +a list, and another function counts the number of full stops in a list. For the sec- +ond we use the SML function full_stop_count shown below. Please note that, +whilst we used a monomorphic type char_list in Chapter 6, here we use the +standard SML type list with the usual polymorphic operators, such as length +and filter. + +(* full_stop_count : char list -> int *) +fun full_stop_count cs + += let + +in + +fun is_full_stop c = c = "." + +length (filter is_full_stop cs) + +end ; + +The second aspect of the solution is to capture the input stream. In SML streams +are accessed using two functions. The predicate end_of_stream(stream) de- +termines whether the end of a stream has been reached. For as long as the predi- +cate yields false (and there are thus elements to be accessed from the stream), the +function input(stream,n) can be used to access the actual characters from the +stream. The argument stream identi(cid:2)es the stream. The argument n speci(cid:2)es +how many characters should be accessed. The function input has a side effect +on the stream, in that it makes sure that a subsequent call to input will cause the +next character(s) to be accessed. A complete SML function to transfer all charac- + +Revision: 6.33 + +(cid:0) +(cid:4) +(cid:10) +(cid:4) +(cid:2) +(cid:4) +(cid:1) +(cid:3) +(cid:8) +(cid:0) +(cid:8) +(cid:23) +(cid:0) +(cid:0) +(cid:10) +(cid:3) +(cid:1) +(cid:0) +(cid:8) +(cid:29) +(cid:0) +(cid:1) +(cid:3) +(cid:8) +’ +(cid:3) +(cid:1) +(cid:0) +(cid:8) +(cid:0) +(cid:146) +(cid:16) +(cid:146) +* + 7.1. Countingsentences: streambasics + +215 + +ters from a stream into a list could be written as follows: + +(* stream_to_list : instream -> char list *) +fun stream_to_list stream + += if end_of_stream stream + +then [] +else input(stream,1) :: stream_to_list stream ; + +Note that stream_to_list must rely on a side effect on the stream. This can +be seen if we consider what would happen if input and end_of_stream had +been pure functions. In this case, the stream would not change from one recur- +sive call of stream_to_list to the next; therefore the test end_of_stream +would always give the same result (either always true, or always false). +In the +case end_of_stream always yields false, stream_to_list would return the +empty list, otherwise it would never terminate. Neither of these are the intended +behaviour of stream_to_list, so it must do its useful work with a side effect. + +The (cid:2)rst solution to the problem of counting sentences in a text combines the + +two functions stream_to_list and full_stop_count as follows: + +(* sentence_count : instream -> int *) +fun sentence_count stream + += full_stop_count (stream_to_list stream) ; + +The function sentence_count is elegant but inef(cid:2)cient: It remembers the entire +contents of the stream, while it only needs a single element of the stream. The +solution to this problem is to combine counting full stops with accessing stream +elements. We discuss this optimisation in the next section, after having introduced +the C equivalents of the functions full_stop_count, stream_to_text, and +sentence_count. + +Using the techniques of Chapter 6, we can develop the C version of + +full_stop_count. Here is the result: + +int full_stop_count( char_list cs ) { + +int stops = 0 ; +while( cs != NULL ) { +if( head( cs ) == (cid:146).(cid:146) + +) { + +stops++ ; + +} +cs = tail( cs ) ; + +} +return stops ; + +} + +A stream in C has the type FILE *. To access the elements of a stream, C offers +the primitive getc( stream ). If there is at least one character available, getc +will return that element. Otherwise it will return the integer EOF (which stands for +End Of File). Note that getc results in an integer; a small subset of these integers +denote legal character values that can be read. The other integers are used to sig- +nal special ‘out of band’ values for example, the end of the (cid:2)le. It is important to +know that, when the result of getc is stored in a variable of type char, the value +EOF might be lost, as it is not a character. + +Revision: 6.33 + + 216 + +Chapter7. Streams + +A function stream_to_list that uses getc to create a list from the standard + +input can now be implemented in C: + +char_list stream_to_list( FILE * stream ) { + +int c = getc( stream ) ; +if( c == EOF ) { +return NULL ; + +} else { + +return cons( c, stream_to_list( stream ) ) ; + +} + +} + +The function stream_to_list processes one character at a time. This charac- +ter is then stored as the head of the result list using the cons function. The +rest of the input is read by a recursive invocation of stream_to_list. The +stream_to_list function returns an empty list using the NULL pointer when +it encounters the end of the input. + +We can now give a naive, but elegant, C function sentence_count to count + +the number of full stops in a text: + +int sentence_count( FILE * stream ) { + +return full_stop_count( stream_to_list( stream ) ) ; + +} + +The given C solution to the sentence count problem would work, but only for +small streams. The solution is inef(cid:2)cient because it requires an amount of store +proportional to the length of the stream. There are two reasons why this is the +case. Firstly, the function stream_to_list uses an amount of stack space pro- +portional to the length of the stream. Secondly, the entire stream is transferred +into the store during the computation. We will solve both ef(cid:2)ciency problems us- +ing the techniques that were developed in Chapters 3 and 6. + +7.1.1 Ef(cid:2)ciently transferring a stream to a list + +The stream_to_list function will recurse over the input, so the stack size re- +quired for this program is proportional to the size of the input stream. This space +ef(cid:2)ciency problem can be solved using tail recursive functions and open lists in +the same way as the ef(cid:2)ciency problems of the copy and append functions were +solved in Chapter 6. The body of stream_to_list is a conditional. To compare +the function copy to stream_to_list, we must rewrite copy so that it also uses +a conditional. Furthermore, the functions in Chapter 6 were all specialised to oper- +ate on the data type char_list. Here we use the standard SML type list. The +two functions are: + +fun stream_to_list stream + +fun copy xs + += if end_of_stream stream + +then [] +else input(stream,1) :: + += if xs = [] +then [] +else head xs :: + +stream_to_list stream ; + +copy (tail xs) ; + +Revision: 6.33 + + 7.1. Countingsentences: streambasics + +217 + +The two functions have the same structure. The main difference is that the list xs +plays the same role in copy as the stream does in stream_to_list. In detail, +the differences are: + +The arguments. The function copy has an explicit argument representing the list +being accessed. The function stream_to_list relies on the SML primitive +input to remember at which point the current (cid:2)le is being read. + +The termination condition. The test of ‘end of input’ for copy checks whether +the end of the list has been reached using xs = []. The corresponding test +end_of_stream stream in stream_to_list checks whether the end of +the stream has been reached. + +The next element. While the end of the input has not been reached, copy +constructs a new list element using the next element of the input list +xs while stream_to_list uses the character it has just accessed using +input(stream,1). + +Side-effects. The copy function is pure, that is, + +it has no side effect. The +stream_to_list function is impure, since it has a side effect on the stream. + +Making changes to the open list version of copy that re(cid:3)ect the above differences +yields the following ef(cid:2)cient C version of stream_to_list. The changes have +been annotated in the comments: + +char_list stream_to_list( FILE * stream ) { + +/* name */ + +char_list accu = NULL ; +char_list last ; +int c; +if( (c = getc(stream) ) != EOF ) { + +last = accu + +/* c declaration */ +/* test on end */ + += cons( c, NULL ) ; + +/* c not head.. */ +*/ +/* no statement here because getc side effects +while( (c = getc(stream) ) != EOF ) { /* test on end */ + +last = last->list_tail + += cons( c, NULL ) ; + +/* c not head.. */ +*/ + +/* no statement here because getc side effects + +} + +} +return accu ; + +} + +Please note the use of assignments in expressions here to save the character just +read for later use. This is idiomatic C and also quite clear. + +Exercise 7.1 Rewrite stream_to_list without assignments in expressions and + +comment on the resulting duplication of code. + +Exercise 7.2 Another implementation of stream_to_list would use pointers +Implement + +to pointers, as in the second form of copy and append. +stream_to_list using pointers to pointers. + +Revision: 6.33 + + 218 + +Chapter7. Streams + +The function stream_to_list ef(cid:2)ciently transfers text from a stream into a list. +This avoids the problem of the unbounded amount of stack space in our initial +solution to the sentence count problem. + +7.1.2 Avoiding the intermediate list + +The SML and C solutions of the sentence count problem transfer the entire con- +tents of the stream into the store before the function full_stop_count can count +the number of full stops. This is not necessary: the elements of the stream could +be read step by step, while counting the full stops at the same time. So far, our +efforts to make stream_to_list ef(cid:2)cient are necessary, but not suf(cid:2)cient. For as +long as one of the functions involved in the solution causes inef(cid:2)ciency, the entire +solution will be inef(cid:2)cient. + +Here is an ef(cid:2)cient version of sentence_count. It uses an auxiliary function +count to do the real work. This SML function shows how the two processes of +reading and counting have been merged: + +(* sentence_count : instream -> int *) +fun sentence_count stream + += let + +fun count stops + += if end_of_stream stream + +then stops +else if input (stream, 1) = "." + +then count (stops+1) +else count stops + +in + +count 0 + +end ; + +The auxiliary function count is ef(cid:2)cient because: + +(cid:1) count is tail-recursive. + +(cid:1) count does not create intermediate list structure. + +Exercise (cid:0) 7.3 Prove that the ef(cid:2)cient version of sentence_count is equivalent + +to the inef(cid:2)cient version of the previous section. + +The ef(cid:2)cient C version of sentence_count is: + +int sentence_count( FILE * stream ) { + +int stops = 0 ; +while( true ) { + +int c = getc( stream ) ; +if( c == EOF ) { +return stops ; +} else if( c == (cid:146).(cid:146) + +) { + +stops++ ; + +Revision: 6.33 + + 7.1. Countingsentences: streambasics + +219 + +} + +} + +} + +Removing the need for the intermediate list is not only more ef(cid:2)cient in space, but +it also makes the program run faster. + +7.1.3 IO in C: opening (cid:2)les as streams + +A C program may operate on several streams at the same time. Three prede(cid:2)ned +streams are always available: stdin for accessing the standard input stream, +stdout for accessing the standard output stream, and stderr which is a stream +for writing error messages. + +Further input and output streams can be made available to the program using +the function fopen, which creates a stream so that it reads from, or writes to a (cid:2)le. +This function has two parameters, the (cid:2)rst parameter is the name of the (cid:2)le to be +opened, the second parameter is the mode. The two most frequently used modes +are "r" (which results in a stream from which input can be read) and "w" (which +results in a stream to which output can be written). Other modes, amongst oth- +ers for appending to (cid:2)les, are speci(cid:2)ed in the C manual [7]. The function fopen +will return a stream (of type FILE *, de(cid:2)ned in stdio.h), if the (cid:2)le cannot be +opened, it will return the value NULL. + +When the program is (cid:2)nished with a stream, the function fclose should be + +called to close the stream. + +We have seen two functions operating on streams so far: printf which +printed to the standard output and getc which reads a character from a speci(cid:2)ed +stream. They are part of two families of functions for reading data from streams, +and writing data to streams. + +Input + +There are three more functions to read from an input stream: getchar, scanf, +and fscanf. The function getchar(), reads a character from the standard input +stream, it is the same as getc( stdin ). The function scanf reads a number of +data items of various types from the standard input stream and stores the values +of these data items (scanf stands for ‘scan formatted’). The function scanf can +be used to read strings, integers, (cid:3)oating point numbers, and characters. The (cid:2)rst +argument of scanf speci(cid:2)es what needs to be read; all other arguments specify +where the data should be stored. As an example of scanf, consider the following +call: + +int i, n ; +char c ; +double d ; +n = scanf("%d %c %lf", &i, &c, &d ) ; + +This section of code will read three data items: an integer (because of the %d in the +format string), which is stored in i; a character (denoted by the %c in the format + +Revision: 6.33 + + 220 + +Chapter7. Streams + +string), which will be stored in the variable c; and a (cid:3)oating point number, which +will be stored in d, indicated by the %lf (more about this %-sequence later on). The +return value of scanf is the number of items that were successfully read. Suppose +the input stream contains the following characters: + +123 q 3.14 + +The variable i will receive the value 123, c will receive the value (cid:146)q(cid:146) +, and d will +receive the value 3.14. The function call returns 3 to the variable n because all +items were read correctly. Suppose the stream had contained instead: + +123/*3.14 + +Now the scanf would have read the 123 into i, read (cid:146)/(cid:146) +into c, and returned +2, as the asterisk is not (part of) a valid (cid:3)oating point number. When scanf fails, +the next use of the stream will start at the (cid:2)rst character that did not match, the +asterisk in this example. + +Any character in the format string of scanf that does not belong to a %-sequence +must be matched exactly to characters in the input stream. The exception to this +rule is that spaces in the format string match any sequence of white space on the +input stream. Consider the following call as an example: + +int i, n ; +char c ; +n = scanf( "Monkey: %d %c", &i, &c ) ; +This will give the value 2 to the variable n if the input is: + +Monkey: 13 + +q + +It will return 0 to n if the input is: + +Money: 100000 + +In the latter case, the characters up to Mon will have been read, the next character +on the stream will be the e from Money. + +The function scanf returns any number of results to its caller through its +pointer arguments. It is convenient to do so in C, but, as we have already seen, +it is a type-unsafe mechanism: the compiler cannot verify that the pointers passed +to scanf are pointers of the right type. The following call will be perfectly in or- +der according to the C compiler: + +int i, n ; +char c ; +double d ; +n = scanf("%lf %d %c", &i, &c, &d ) ; + +However, scanf will attempt to store a (cid:3)oating point number in the integer vari- +able i, an integer in the character variable c, and a character in the double variable +d. Therefore, this program will execute with unde(cid:2)ned results. + +The way (cid:3)oating point numbers are accessed is a source of problems. A %f- +sequence reads a single precision (cid:3)oating point number, while %lf reads a double +precision (cid:3)oating point number. Until now we have ignored the presence of single +precision (cid:3)oating point numbers of type float, but scanf must know the differ- +ence. Writing a single precision (cid:3)oating point into the store of a double precision + +Revision: 6.33 + + 7.1. Countingsentences: streambasics + +221 + +number does not give the desired result. Another common error using scanf is to +forget the & in front of the arguments after the format string, causing the value to +be passed instead of a pointer, most likely resulting in the function scanf crash- +ing. + +The function scanf always accesses the standard input stream stdin. +The function fscanf has an extra argument that speci(cid:2)es the stream to be +accessed. +to +fscanf( stdin, ... ). An example of its use is given after the description +of the output functions. + +Similar to getchar and getc, scanf( ... ) is identical + +Output + +Similar to the family of input functions, getchar, getc, scanf, and fscanf, +there is a family of output functions: putchar, putc, printf and fprintf. +The companion of getchar to put characters on the output stream stdout +is called putchar. Here is a sequence of six statements that is equivalent to +printf( "Hello\n" ): + +putchar( (cid:146)H(cid:146) +putchar( (cid:146)l(cid:146) + +) ; putchar( (cid:146)e(cid:146) +) ; putchar( (cid:146)o(cid:146) + +) ; putchar( (cid:146)l(cid:146) +) ; putchar( (cid:146)\n(cid:146) + +) ; + +) ; + +The function call putchar( c ) is equivalent to a call to printf( "%c", c ). +The function putc( c, stream ) allows a character c to be output to the +named stream. Thus putchar( c ) is equivalent to putc( c, stdout ). Fi- +nally, the function fprintf has an extra argument that speci(cid:2)es to which stream +to write: printf( ... ) is identical to fprintf( stdout, ... ). + +An Input/Output Example + +The following program fragment reads an integer and a double precision (cid:3)oating +point number from the (cid:2)le (cid:147)input.me(cid:148) and writes the sum to the (cid:2)le (cid:147)result(cid:148): + +int i, n ; +double d ; +FILE *in = fopen( "input.me", "r" ) ; +if( in != NULL ) { + +FILE *out = fopen( "result", "w" ) ; +if( out != NULL ) { + +n = fscanf( in, "%d %lf", &i, &d ) ; +if( n == 2 ) { + +fprintf( out, "%f\n", d+i ) ; + +} else { + +fprintf( stderr, "Wrong format in input\n" ) ; + +} +fclose( out ) ; + +} +fclose( in ) ; + +} + +Revision: 6.33 + + 222 + +Chapter7. Streams + +Exercise 7.4 Give SML and C versions of a function list_to_stream to transfer + +the contents of a list of characters to a stream. + +7.2 Mean sentence length: how to avoid state + +The previous problem counted the number of sentences in a text. A slightly more +complicated problem is not only to count the number of sentences, but to calculate +the mean sentence length: + +mean sentence length (cid:0) + +(cid:1).(cid:2) + +mean sentence length + +div sentence count + +(7.2) + +As we have already developed an ef(cid:2)cient function sentence_count to count +the number of sentences, all we have to do is write a function character_count +to count the number of characters in a stream. Then we may divide the number +of characters by the number of sentences. If our function sentence_count is a +good building block, we should be able to reuse it for this purpose. + +Here is an ef(cid:2)cient function character_count, which is basically a simpli- + +(cid:2)ed version of sentence_count: + +(* character_count : instream -> int *) +fun character_count stream + += let + +fun count chars + += if end_of_stream stream + +then chars +else let + +val c = input (stream, 1) + +in + +end + +count (chars+1) + +in + +count 0 + +end ; + +The mean sentence length would be given by the SML function below: + +(* mean_sentence_length : instream -> int *) +fun mean_sentence_length stream + += (character_count stream) div +(sentence_count stream) ; + +Unfortunately, executing this program will not produce the expected result. Ei- +ther the function mean_sentence_length will produce the answer 0 or it will +fail with a ‘divide by zero’ exception. How can this be? The two building blocks +sentence_count and character_count are not faulty. The reason is that +the function input, which is used by both, has a side effect and modi(cid:2)es the +stream. Depending on the order in which the two operands of the div operator + +Revision: 6.33 + +(cid:4) +(cid:10) +(cid:4) +(cid:8) +(cid:10) +(cid:2) +(cid:4) +(cid:1) +(cid:3) +(cid:8) +(cid:0) +(cid:1) +(cid:8) +(cid:3) +(cid:8) +(cid:1) +(cid:3) +(cid:8) + 7.2. Meansentencelength: howtoavoidstate + +223 + +are evaluated, either character_count accesses the entire stream, so that when +sentence_count is evaluated, it (cid:2)nds the stream empty, or vice versa. This +shows the danger of using functions that have side effect: they make it dif(cid:2)cult +to create good building blocks. It depends on the circumstances whether a func- +tion that relies on side effects has the desired behaviour or not. The C versions +of sentence_count and character_count also modify the stream as a side +effect, so there is no point in trying to pursue development on the present basis. + +The mean sentence length problem could be solved by transferring the entire +stream into a list and then to count the characters and the sentences. Such a so- +lution was dismissed earlier because of the inherent inef(cid:2)ciency and also the im- +possibility of processing arbitrary large streams. A better solution is to combine +the activities of sentence_count and character_count into a single function +that accesses the elements of the stream just once. + +Such a combined function can be developed, + +since the structures of +sentence_count and character_count are so similar. The SML functions can +be merged, whilst taking care not to duplicate the elements they have in common: + +(* mean_sentence_length : instream -> int *) +fun mean_sentence_length stream + += let + +fun count chars stops + += if end_of_stream stream +then chars div stops +else if input (stream, 1) = "." + +then count (chars+1) (stops+1) +else count (chars+1) stops + +in + +count 0 0 + +end ; + +The auxiliary function count inspects each character of the input stream in turn +and counts the number of full stops and characters in parallel. This means that +the input stream does not have to be remembered, and the implementation can +discard each character of the stream after it has been inspected. + +The version of mean_sentence_length above can be transformed into an + +ef(cid:2)cient C function without dif(cid:2)culty: + +int mean_sentence_length( FILE * stream ) { + +int chars = 0 ; +int stops = 0 ; +int c ; +while( true ) { + +c = getc( stream ) ; +if( c == EOF ) { + +return chars / stops ; + +} else if( c == (cid:146).(cid:146) + +) { + +stops++ ; + +} + +Revision: 6.33 + + 224 + +} + +} + +chars++ ; + +Chapter7. Streams + +This is an ef(cid:2)cient function to calculate the mean sentence length. Many functions +that consume a stream can be written using a while loop that iterates over the char- +acters of the input stream, accumulating all the required information. + +7.3 Counting words: how to limit the size of the state + +The programs developed for the previous two examples operated on the stream +on a per character basis. Programs often act on larger units of data. An example +of such a problem is the word-count problem. Given a text (for example the text of +this book), we may wish to count how often a certain word (for example, the word +(cid:147)cucumber(cid:148)) occurs in the text (the answer is 11 times). + +The number of occurrences of the word (cid:7) + +is given by the function +below, where both the word and the text are represented by a sequence of charac- +ters: + +in the text (cid:1) + +(cid:1)(cid:3)(cid:2) + +(cid:5)(cid:9)(cid:2) + +(cid:4)-(cid:10) + +(cid:8)(cid:11)(cid:10) + +word count + +word count + +(cid:1)(cid:1)(cid:0) + +(cid:1)(cid:3)(cid:2) + +(cid:1)(cid:1)(cid:0) + +(7.3) + +An algorithm to count all the occurrences of the word w would try to match it to +each position in the text t. Using lists to represent both the word and the text, +successful matches can be counted as follows in SML: + +(* word_count : char list -> char list -> int *) +fun word_count ws [] + += 0 + +| word_count ws (t::ts) = if match ws (t::ts) + +word_count ws ts ; +The word_count function requires a subsidiary function match to check whether +a word matches the text at a particular position. The match function compares the +characters from the word and the text. It yields false if either the text contains too +few symbols or if a mismatch is found: + +then 1 + word_count ws ts +else + +(* match : char list -> char list -> bool *) +fun match [] + +t + += true += false + +| match (w::ws) [] +| match (w::ws) (t::ts) = w = (t:char) andalso match ws ts ; + +Exercise (cid:0) 7.5 Given a word (cid:7) + +, a text (cid:1) , and (7.3). Prove that: word count + +word_count w t + +As a (cid:2)rst step, we use the naive approach: transfer the contents of a stream into a +list and then count the number of occurrences of the word (cid:147)cucumber(cid:148): + +(* main : instream -> int *) + +Revision: 6.33 + +(cid:0) +(cid:4) +(cid:10) +(cid:1) +(cid:1) +(cid:2) +(cid:4) +(cid:1) +(cid:7) +(cid:14) +(cid:1) +(cid:8) +(cid:0) +(cid:8) +(cid:23) +(cid:1) +(cid:1) +(cid:2) +(cid:14) +(cid:8) +(cid:29) +(cid:1) +(cid:0) +(cid:3) +(cid:7) +(cid:3) +* +(cid:1) +(cid:7) +(cid:14) +(cid:1) +(cid:8) +(cid:0) + 7.3. Countingwords: howtolimit thesizeofthestate + +225 + +fun main stream = + +let + +val word = explode "cucumber" +val text = stream_to_list stream + +in + +word_count word text + +end ; + +Exercise 7.6 Rewrite word_count above as a tail recursive function using an ac- +cumulating argument and translate the result into a loop based C imple- +mentation. + +Exercise 7.7 Give an ef(cid:2)cient C implementation of match. + +Exercise 7.8 Write a main program, using word_count and stream_to_list, +to count the number of occurrences of the word (cid:147)cucumber(cid:148) on the stdin +stream: + +7.3.1 Using a sliding queue + +As we have seen in the previous sections, (cid:2)rst transferring the contents of a stream +into a list and then manipulating the list is not ideal. For the word count problem, +we need a queue to buffer elements from the input stream: each time a new char- +acter of the stream is needed, it is entered to the rear of the queue. Each time a +character has ceased to be useful, it is deleted from the front of the queue. The net +effect of this is that the queue appears to advance over the text and that the word +shifts along with the queue. + +To illustrate this process suppose that the text contains the characters (cid:147)cucu- +cumbers(cid:148) and that we have seen that the (cid:2)rst character of the text matches the +(cid:2)rst character of the word (cid:147)cucumber(cid:148). This situation is shown graphically be- +low. Here the portion of the text that has been accessed so far is labelled t, and the +word is labelled w. The front of the queue is to the left of the picture, and the rear +of the queue is to the right. + +t: + +w: + +c + +c + +u + +c + +u + +m + +b + +e + +r + +The word and the text are shown with corresponding matching characters verti- +cally aligned. Now the second character of the text must be accessed for it to be +compared to the second character of the word. The character (cid:146)u(cid:146) +enters the queue +at the rear (right). + +Revision: 6.33 + + 226 + +Chapter7. Streams + +t: + +w: + +c + +c + +u + +u + +c + +u + +m + +b + +e + +r + +After accessing another three characters a mismatch occurs, because the text reads +(cid:147)cucuc. . . (cid:148) and the word reads (cid:147)cucum. . . (cid:148). This causes the match function to +return false to word_count. The queue of elements from the text is now in the +following state: + +t: + +w: + +c + +c + +u + +u + +c + +c + +u + +u + +c + +m + +b + +e + +r + +The function count makes the next step; it advances the position of the queue in +an attempt to match (cid:147)u. . . (cid:148) with (cid:147)c. . . (cid:148). The character (cid:146)c(cid:146) +at the front of the queue +has now left. + +t: + +w: + +u + +c + +c + +u + +u + +c + +c + +u + +m + +b + +e + +r + +The match now fails immediately. The queue is advanced yet again, so that now +also the character (cid:146)u(cid:146) +at the front of the queue disappears. + +t: + +w: + +c + +c + +u + +u + +c + +c + +u + +m + +b + +e + +r + +Now we see the bene(cid:2)ts of using a queue sliding over the text. The matching of +the characters (cid:146)c(cid:146) +can be done immediately; there is no need to +access new elements from the stream because they have been remembered. + +and (cid:146)c(cid:146) + +, (cid:146)u(cid:146) + +7.3.2 Implementing the sliding queue in SML + +An implementation of the sliding queue should satisfy the following require- +ments: + +(cid:1) New elements should be appended to the rear of the queue. + +Revision: 6.33 + + 7.3. Countingwords:howtolimit thesizeofthestate + +227 + +(cid:1) Accessing the queue should be supported ef(cid:2)ciently. + +It should be possible to discard elements from the front of the queue as soon +as they are no longer needed. + +The sliding queue can be implemented on the basis of a list. We will (cid:2)rst study +this in SML and then give an optimised implementation in C. The SML datatype +queue that we use for the queue is a tuple consisting of an input stream and a list: + +datatype (cid:146)a queue = Queue of (instream * (cid:146)a list) ; + +The actual elements that are part of the queue are stored in the list. We are aiming +to always keep a certain number of elements in the list. In the context of the word +count problem, we know in advance that we will be needing as many elements +as there are elements in the word that we are counting. To support the transfer of +elements from the text, we need to remember with which stream we are dealing. + +Initially, our program will have to create a queue with a number of characters + +from the stream entered into the queue. Here is an SML function to do this: + +(* create : instream -> int -> char queue *) +fun create stream n + += Queue (stream, stream_to_list stream n) ; + +The function create tries to access n characters from the stream and stores these +in the list. We are using here a modi(cid:2)ed version of stream_to_list which reads +no more than n characters. The identity of the stream must be remembered for +future use. + +Exercise 7.9 Give an ef(cid:2)cient C version of stream_to_list which reads no + +more than a given number n of elements. + +To fetch the contents of the queue, we de(cid:2)ne the SML function fetch: + +(* fetch : (cid:146)a queue -> (cid:146)a list *) +fun fetch (Queue (stream, list)) = list ; + +When advancing the queue we must make sure that a new character is automat- +ically entered when an old character is removed. New characters must be trans- +ferred from the stream involved. Here is the SML function advance taking care +of this: + +(* advance : char queue -> char queue *) +fun advance (Queue (stream, list)) += if end_of_stream stream + +then Queue (stream, tail list) +else Queue (stream, tail list @ + +[input (stream, 1)] ) ; + +Appending a newly accessed stream element to the rear of the queue is relatively +expensive as it requires the use of the standard SML append operator @. In the +optimised C version of this solution, we will use the open list technique rather +than an append operation. + +Revision: 6.33 + +(cid:1) + 228 + +Chapter7. Streams + +Finally, we need a predicate is_empty to signal when no further elements are + +available: + +(* is_empty : (cid:146)a queue -> bool *) +fun is_empty (Queue (stream, list)) = list = [] ; + +To use these four primitives, the function word_count should be rewritten to op- +erate on a sliding queue, rather than on a list. + +(* word_count : char list -> char queue -> int *) +fun word_count ws ts += if is_empty ts +then 0 +else if match ws (fetch ts) + +then 1 + word_count ws (advance ts) +else + +word_count ws (advance ts) ; + +The function match does not need to be altered, as the result of applying fetch +to the queue is a list. To complete the SML queue based solution of the word count +problem, we give a main function: + +(* main : instream -> int *) +fun main stream = + +let + +val word = explode "cucumber" +val text = create stream (length word) + +in + +word_count word text + +end ; + +7.3.3 Implementing the sliding queue in C + +The sliding queue implementation in SML uses the append operator to enter new +elements from the stream into the queue. We have seen that this is an inef(cid:2)cient +operation. The same operation can be implemented ef(cid:2)ciently if we use open lists. +To develop a C data structure and a set of functions that implement the sliding +queue with open lists, we need to keep track of the end of the list for the queue +operations. Therefore, we de(cid:2)ne the equivalent of our SML type queue with a +provision for keeping track of the beginning as well as the end of the list. + +typedef struct queue_struct { + +* queue_stream ; + +FILE +char_list queue_first ; +char_list queue_last ; + +} * char_queue ; + +As in SML, our C program will have to be able to create an initial queue with a +number n of elements already entered into the list: + +#define queue_struct_size sizeof( struct queue_struct ) + +Revision: 6.33 + + 7.3. Countingwords:howtolimit thesizeofthestate + +229 + +char_queue create( FILE * stream, int n ) { + +char_queue q +if( q == NULL ) { + += malloc( queue_struct_size ) ; + +printf( "create: no space\n" ) ; +abort( ) ; + +} +q->queue_stream= stream ; +q->queue_first = stream_to_list( stream, n ) ; +q->queue_last = find_last( q->queue_first ) ; +return q ; + +} + +The code of create is straightforward, except that we need to keep track of the +last element of the list. There are two possible ways of implementing this. Firstly, +we could modify stream_to_list so that it delivers the required pointer. This +should not be dif(cid:2)cult as the open list version of stream_to_list already keeps +track of this information. The disadvantage is that stream_to_list would then +have to return two, rather than just one, pointers, and this is not conveniently done +in C. + +The second way of getting the pointer to the last element of the list is simply +by writing a new function find_last to do that. This is the alternative that we +are favouring here. It has the disadvantage that the list is created (cid:2)rst and then +traversed just to (cid:2)nd the end. However, since we may expect this list to be short, +this should not be a problem. Furthermore, the extra traversal only happens once, +during initialisation. + +char_list find_last( char_list current ) { + +char_list previous = NULL ; +while( current != NULL ) { + +previous = current ; +current = tail( current ) ; + +} +return previous ; + +} + +The function find_last uses two ‘chasing’ pointers: current points at the cur- +rent cons cell and previous at the one before. As soon as current reaches the +end of the list (the NULL pointer), previous will be pointing at the last cons cell +of the list. The function find_last returns the NULL pointer if the list is empty. + +The function to fetch the contents of the queue is implemented in C as follows: + +char_list fetch( char_queue q ) { + +return q->queue_first ; + +} + +To advance the queue, we will need to use the pointer to the last cell of the list, so +that the append operation can be supported through the open list technique. To +make advance ef(cid:2)cient, we will write it to modify the old queue, hence having a +side effect. To remind us of this choice, the return type of advance is void. + +void advance( char_queue q ) { + +Revision: 6.33 + + char_list old, new; +int c = getc( q->queue_stream ) ; +if( c != EOF ) { + +new = cons( c, NULL ) ; +q->queue_last->list_tail = new ; +q->queue_last = new ; + +Chapter7. Streams + +/* 1 */ +/* 2 */ +/* 3 */ + +} +old = q->queue_first ; +/* 4 */ +q->queue_first = q->queue_first->list_tail ; /* 5 */ +/* 6 */ +free( old ) ; + +230 + +} + +to the queue and to remove the character (cid:146)c(cid:146) + +The working of advance is shown graphically below. The state of the queue as +it exists when advance is called is drawn as solid lines. We are about to add the +character (cid:146)b(cid:146) +. The dashed lines rep- +resent the changes made to the bookkeeping of the queue. The new element is put +into a singleton list new (1). This list is then connected to the tail of the last cell of +the queue (2). The queue_last (cid:2)eld is redirected to point at the new cell (3). Re- +from the queue involves redirecting the queue_first +moving the character (cid:146)c(cid:146) +(cid:2)eld to point at the cell holding the letter (cid:146)u(cid:146) +(5). The space occupied by the old +cell must be freed, which requires us to keep a pointer old to the cell (4) and when +all modi(cid:2)cations have been done to free it (6). + +q: + +q->queue_stream: + +q->queue_first: + +q->queue_last: + +(5) + +c + +(5) + +old (4,6) + +new (1) + +u + +m + +(2) + +b + +(3) + +queue + +Here is the predicate is_empty in C: + +bool is_empty( char_queue q ) { + +return q->queue_first == NULL ; + +} + +Finally, word_count needs to be rewritten to use the queue instead of the list: + +int word_count( char_list ws, char_queue ts ) { + +int accu = 0 ; +while( ! is_empty( ts ) ) { + +if( match( ws, fetch( ts ) ) ) { + +accu++ ; + +} +advance( ts ) ; + +Revision: 6.33 + + 7.3. Countingwords:howtolimit thesizeofthestate + +231 + +} +return accu ; + +} + +Exercise 7.10 Implement a main program to initialise the queue and count the + +number of occurrences of some word in a text. + +7.3.4 Counting words using arrays + +The process of creating a queue from a stream of characters as shown in the pre- +vious section is effective, but its ef(cid:2)ciency could still be improved. For each each +iteration of word_count, a list cell has to be allocated, and another cell has to be +freed. Allocation of cells is usually expensive, and if performance is important, it +is better avoided. Another data structure might be more appropriate for buffer- +ing the input stream, the array. Firstly, an array is allocated all at once rather than +piecemeal, as is the case for the cells of a list. Secondly, an array offers more ef(cid:2)- +cient access to arbitrary elements than a list. Below, we will show how arrays can +be used to implement the word count problem. + +Let us begin by revising the queue data type to use an array instead of a list. +The SML version of the data type is shown below. The actual elements that are +part of the queue are now stored in an array. We aim to always keep a certain +number of elements in the queue. This is an important consideration as arrays are +not easily extended. If we can allocate an array of the right size at the beginning, +the array based queue will never have to do any storage allocation or deallocation. +We cannot guarantee that all elements of the array will always contain useful in- +formation, so we maintain the index of the last element that is actually valid. We +could have chosen to maintain a count of the valid elements instead. This turns +out to be less convenient, as we will see. + +datatype (cid:146)a queue = Queue of (instream * int * (cid:146)a array) ; + +Here is the equivalent data structure in C: +typedef struct queue_struct { + +FILE * queue_stream ; +int queue_valid ; +char * queue_array ; + +} * char_queue ; + +To create the queue, we use the stream_to_list function to transfer the (cid:2)rst n +elements of the stream to a list. Then we use the function list_to_array from +Chapter 6 to create the array. As the function create is only used once (during +initialisation), it should not matter that it creates a small intermediate list structure. +It is important to make functions ef(cid:2)cient that are often used. Spending effort on +functions that are rarely used does not pay. This tradeoff is often referred to as +the 90%/10% rule: a program will often spend 90% of its time in only 10% of its + +Revision: 6.33 + + 232 + +Chapter7. Streams + +code. Therefore spending effort to optimise this 10% is worthwhile. Optimising +the remaining 90% is rarely worthwhile. + +(* create : instream -> int -> char queue *) +fun create stream n + += let + +in + +val list = stream_to_list stream n +val valid = length list - 1 +val array = list_to_array list + +Queue (stream, valid, array) + +end ; + +In C, the same function is: + +#define queue_struct_size sizeof( struct queue_struct ) + +char_queue create( FILE * stream, int n ) { + +char_list list = stream_to_list( stream, n ) ; +char_queue q += malloc( queue_struct_size ) ; +if( q == NULL ) { + +printf( "create: no space\n" ) ; +abort( ) ; + +} +q->queue_stream = stream ; +q->queue_valid = length( list )-1 ; +q->queue_array = list_to_array( list ) ; +return q ; + +} + +Fetching the contents of the queue is straightforward: + +(* fetch : (cid:146)a queue -> (cid:146)a array *) +fun fetch (Queue (stream, valid, array)) = array ; + +The C version of fetch is: + +char * fetch( char_queue q ) { + +return q->queue_array ; + +} + +Exercise 7.11 We might need an extra function valid to tell us how many valid +elements there are in the queue. Give these functions in C and SML. + +Advancing the queue with an array based implementation is now slightly compli- +cated, as we will need to shift the contents of the array. Here is the SML version of +advance: + +(* advance : char queue -> char queue *) +fun advance (Queue (stream, valid, array)) + += let + +fun shift i = if i < valid + +Revision: 6.33 + + 7.3. Countingwords: howtolimit thesizeofthestate + +233 + +then sub (array, i+1) +else input (stream, 1) + +in + +if end_of_stream stream + +then Queue (stream, valid-1, tabulate (valid, shift)) +else Queue (stream, valid, tabulate (valid+1, shift)) + +end ; + +Here we see that maintaining the index of the last valid element of the array is +indeed convenient. If a counter had been used instead, several more increments +and decrements would have to be programmed. The C version of the shifting +advance is: + +void advance( char_queue q ) { + +int c = getc( q->queue_stream ) ; +int i ; +for (i = 0; i < q->queue_valid; i++) { + +q->queue_array[i] = q->queue_array[i+1] ; + +} +if( c == EOF ) { + +q->queue_valid -- ; + +} else { + +q->queue_array[q->queue_valid] = c ; + +} + +} + +The function advance needs to make as many steps as there are characters in the +array. Shifting the array is an expensive operation if the array is large. A more +ef(cid:2)cient but more complicated version of wordcount is discussed in Exercise 7.13. +The predicate to signal that no further elements are available requires some +care. As the valid component of the queue data type maintains the index of the +last valid element, a value of 0 for queue_valid means that one element of the +array is still available. Thus a value of -1 signals that the queue is empty. Here is +the SML version of the predicate: + +(* is_empty : (cid:146)a queue -> bool *) +fun is_empty (Queue (stream, valid, array)) = valid = ˜1 ; + +In C the code is: + +bool is_empty( char_queue q ) { +return q->queue_valid == -1 ; + +} + +Exercise 7.12 Rewrite the SML and C versions of word_count and match so that + +they become suitable for array based queues. + +Exercise 7.13 The functions above shift all the elements in the array one posi- +tion to the left on every advance. This operation is increasingly expensive +for long words. An alternative is to use a cyclic buffer, where the text is + +Revision: 6.33 + + 234 + +Chapter7. Streams + +‘wrapped around’. The advance operation overwrites the oldest charac- +ter in the buffer, and the beginning of the buffer is de(cid:2)ned to start at the +to be (cid:0) , then the con- +next character. If we denote the start of the buffer (cid:1) +tents is (cid:1) +. The next element to be +overwritten is (cid:1) +, whereupon (cid:0) is incremented. Devise a solution that uses +a cyclic buffer. + +(cid:16)(cid:18)(cid:16)(cid:21)(cid:16) + +(cid:16)(cid:18)(cid:16)(cid:21)(cid:16) + +(cid:8)(cid:16)(cid:14) + +(cid:8)(cid:16)(cid:14) + +(cid:8)(cid:16)(cid:14) + +(cid:8)(cid:16)(cid:14) + +(cid:8)(cid:16)(cid:14) + +(cid:1)1(cid:15) + +7.4 Quicksort + +The (cid:2)nal example of this chapter discusses the problem of sorting the contents of a +stream. The problem here is that it is impossible to sort a stream ef(cid:2)ciently without +having access to its entire contents. This time, no optimisations apply that only +keep part of the stream in the store. The problem of ef(cid:2)cient sorting is by itself +interesting and worthy of study. + +To sort data, it should be possible to compare two arbitrary data elements and +to decide which of the two should come (cid:2)rst in a sorted sequence. When given +a sequence (cid:3) of length +(cid:0) and an operation (cid:11) de(cid:2)ned on the elements of the +sequence, the sorted sequence sort + +is: + +sort + +sort + +(cid:1).(cid:2) + +(cid:8)(cid:11)(cid:10) + +(cid:1)(cid:3)(cid:2) + +(cid:8)(cid:16)(cid:14) + +(cid:23)(cid:26)% + +(cid:0)(cid:2)(cid:1) + +(cid:3)(cid:0) + +(cid:16)(cid:18)(cid:16)(cid:18)(cid:16) + +where (cid:23) +and (cid:3) + +(cid:0)(cid:2)(cid:1) + +(cid:16)(cid:18)(cid:16)(cid:18)(cid:16) + +is a permutation of (cid:23)(cid:26)% + +(cid:16)(cid:18)(cid:16)(cid:21)(cid:16) + +(cid:16)(cid:21)(cid:16)(cid:18)(cid:16) + +An elegant divide and conquer algorithm to sort a sequence is quicksort [3]. The +recursive speci(cid:2)cation of quicksort on sequences is given below. Here we are us- +ing the (cid:2)lter function as de(cid:2)ned in Exercise 6.6. The predicates are written as sec- +tions; for example +, when applied to some value (cid:8) + +, is the same as (cid:8) + +. + +(cid:1).(cid:2) + +(cid:8)(cid:11)(cid:10) + +(cid:1).(cid:2) + +qsort + +qsort + +range +(cid:2)lter +(cid:3) (cid:2)lter +(cid:2)lter + +qsort + +qsort + +(cid:8)(cid:16)(cid:14) + +if (cid:8) +otherwise + +Some element (cid:12) of the sequence is used as a ‘pivot’. The three (cid:2)lters partition the +elements less than the pivot, those equal to the pivot (of which there is at least +one), and the elements which are greater than the pivot into three separate sets. +The elements of the (cid:2)rst and third partitions are sorted recursively. The two sorted +partitions are (cid:2)nally joined with the pivot partition to form the result. + +Quicksort can be implemented using both lists and arrays. The list based im- +plementation is elegant, but not ef(cid:2)cient. The array based implementation is com- +plicated, but more ef(cid:2)cient. Both implementations will be discussed in the follow- +ing sections. + +Revision: 6.33 + +(cid:1) +(cid:0) +(cid:1) +(cid:1) +(cid:0) +(cid:2) +(cid:0) +(cid:1) +(cid:0) +(cid:0) +(cid:1) +(cid:1) +% +(cid:1) +(cid:1) +(cid:0) +(cid:1) +(cid:1) +(cid:0) +(cid:0) +(cid:0) +(cid:8) +(cid:1) +(cid:0) +(cid:8) +(cid:15) +(cid:2) +(cid:1) +(cid:3) +(cid:8) +(cid:0) +(cid:4) +(cid:10) +(cid:1) +(cid:4) +(cid:10) +(cid:1) +(cid:8) +(cid:1) +(cid:3) +(cid:8) +(cid:0) +(cid:10) +(cid:3) +(cid:1) +(cid:15) +(cid:0) +(cid:10) +(cid:3) +(cid:1) +(cid:0) +(cid:4) +(cid:8) +* +(cid:14) +(cid:0) +(cid:4) +* +(cid:14) +(cid:15) +* +(cid:1) +(cid:0) +(cid:1) +(cid:8) +(cid:11) +(cid:3) +(cid:1) +(cid:0) +(cid:2) +(cid:8) +(cid:11) +(cid:3) +(cid:1) +(cid:0) +(cid:4) +(cid:8) +(cid:1) +(cid:3) +(cid:10) +(cid:12) +(cid:8) +(cid:10) +(cid:12) +(cid:0) +(cid:4) +(cid:10) +(cid:1) +(cid:4) +(cid:10) +(cid:1) +(cid:8) +(cid:1) +(cid:3) +(cid:8) +(cid:0) +(cid:6) +(cid:7) +(cid:7) +(cid:7) +(cid:7) +(cid:7) +(cid:7) +(cid:8) +(cid:7) +(cid:7) +(cid:7) +(cid:7) +(cid:7) +(cid:7) +(cid:9) +(cid:0) +(cid:12) +(cid:27) +(cid:1) +(cid:3) +(cid:8) +(cid:16) +(cid:1) +(cid:1) +(cid:3) +(cid:10) +(cid:12) +(cid:14) +(cid:3) +(cid:8) +(cid:8) +(cid:1) +(cid:3) +(cid:0) +(cid:12) +(cid:14) +(cid:3) +(cid:8) +(cid:3) +(cid:1) +(cid:1) +(cid:3) +, +(cid:12) +(cid:14) +(cid:3) +(cid:8) +(cid:3) +, +% +(cid:3) +(cid:14) + 7.4. Quicksort + +235 + +7.4.1 Quicksort on the basis of lists + +The speci(cid:2)cation of quicksort uses (cid:2)lters which can be translated directly into +SML: + +(* qsort : char list -> char list *) +fun qsort [] + += [] + +| qsort (p::xs) = let + +fun less_eq x = x <= (p:char) +fun greater x = x > (p:char) + +in + +qsort (filter less_eq xs) + +@ [p] @ + +qsort (filter greater xs) + +end ; + +Local function de(cid:2)nitions are required to capture the value of the pivot p for the +bene(cid:2)t of the comparison operators (See Section 6.4.2). + +The C version of qsort follows the SML version closely. The extra argument +version of filter is used to pass the pivot p to the comparison operators <= and +>. + +char_list qsort( char_list p_xs ) { + +if( p_xs == NULL) { + +return NULL ; + +} else { +char +p = head( p_xs ) ; +char_list xs = tail( p_xs ) ; +char_list ls = extra_filter( less_eq, &p, xs ) ; +char_list gs = extra_filter( greater, &p, xs ) ; +return append( qsort( ls ), + +append( cons( p, NULL ), + +qsort( gs ) ) ) ; + +} + +} + +We cannot de(cid:2)ne local functions in C so the auxiliary functions less_eq and +greater are de(cid:2)ned as separate functions: +bool less_eq( void * arg, + +bool greater( void * arg, + +char x ) { + +char x ) { + +char * p = arg ; +return x <= * p ; + +char * p = arg ; +return x > * p ; + +} + +} + +The C version of qsort above is incomplete: the functions extra_filter, +cons, and append all allocate cells, but the store is not deallocated. Therefore, +this program needs to be amended so that the temporary lists are deallocated. + +Exercise 7.14 Amend the code for quicksort so that redundant lists are deallo- +cated. Assume that append( x, y ) copies the list x, cons creates one + +Revision: 6.33 + + 236 + +Chapter7. Streams + +cell, and extra_filter creates a whole fresh list. + +Exercise 7.15 Write a function main in both SML and in C to call qsort with the + +following short list of characters: + +The list version of quicksort is elegant and compact, and it was not particularly +dif(cid:2)cult to derive. Unfortunately, it is not ef(cid:2)cient because of the large number of +intermediate lists it creates. There are two sources of inef(cid:2)ciency. Firstly, for each +invocation of qsort, the input list is traversed twice, creating two separate parti- +tions in the form of separate lists. Each element (except the (cid:2)rst) of the input list +will end up in one of the two partitions. Thus each call to qsort effectively copies +its entire input list during the partitioning phase. Secondly, the calls to append +create copies of the lists as produced by the recursive calls to qsort. + +In the next section we turn to the array version of qsort with a view of avoid- +ing all copies of intermediate data structures. The price that has to be paid for this +improved ef(cid:2)ciency is considerable complication in partitioning the input data. +An unexpected advantage is that the append operation becomes redundant when +using an array. + +7.4.2 Quicksort on the basis of arrays + +Arrays and lists are both representations of sequences. The difference between +the two representations is in the cost of the operations that can be applied to the +sequence. The quicksort algorithm partitions the input sequence into two separate +Implementing this ef(cid:2)ciently using lists is dif(cid:2)cult, since it requires +sequences. +changing the linkage of the cells of the list. Moving data around in an array is +easier. + +Consider, as an example, the following operation of swapping two elements of +an array. The SML version accesses the elements of the array data at positions i +and j and creates a new array with the values at positions i and j exchanged: + +(* swap : (cid:146)a array -> int -> int -> (cid:146)a array *) +fun swap data i j + += let + +val data_i = sub (data, i) +val data_j = sub (data, j) +val data(cid:146) +val data(cid:146) + += upd (data, j, data_i) += upd (data(cid:146), i, data_j) + +in + +data(cid:146) + +end ; + +In a purely functional language, accessing an element of an array has a time com- +plexity of (cid:0) +operation. In C, both accessing +, because the array can be overwritten. An +and updating an array element is (cid:0) + +and updating an element is an (cid:0) + +(cid:1)(cid:13)(cid:15)(cid:17)(cid:8) + +Revision: 6.33 + +(cid:146) +(cid:0) +(cid:146) +(cid:14) +(cid:146) +(cid:0) +(cid:146) +(cid:14) +(cid:146) +(cid:1) +(cid:146) +(cid:14) +(cid:146) +(cid:0) +(cid:146) +(cid:14) +(cid:146) +(cid:4) +(cid:146) +(cid:14) +(cid:146) +(cid:0) +(cid:146) +(cid:14) +(cid:146) +(cid:1) +(cid:146) +(cid:146) +(cid:146) +(cid:1) +(cid:0) +(cid:8) +(cid:1) +(cid:0) +(cid:8) + 7.4. Quicksort + +237 + +ef(cid:2)cient C version will access the old values at i and j and update them as fol- +lows: + +void swap( char data[], int i, int j ) { + +char data_i = data[i] ; +char data_j = data[j] ; +data[i] = data_j ; +data[j] = data_i ; + +} + +The function swap has a side effect on the array data. The void return type ad- +vertises that swap does its work by a side effect. + +Let us now consider how an array based version of qsort could be developed. +Firstly, the input data is needed in the form of an array. Secondly, the array must +be partitioned such that one partition contains the array elements not exceeding +the pivot and another partition contains the elements greater than the pivot. Ele- +ments equal to the pivot will occupy a partition of their own. Thus, an important +element of the solution is to maintain various indices in the array, in order to keep +tabs on the partitions involved. + +Each call to qsort works on a section of the array, delineated by two indices +l and r (for left and right). The function qsort will leave all other array elements +undisturbed. The partitions within the range l to r will be further delineated us- +ing index variables j and i. The elements less than or equal to the pivot are at +positions l to j; those greater than or equal to the pivot are at positions i to r. +The intervening elements (from j+1 to i-1) are equal to the pivot and require no +further sorting. Here is a diagram showing the partitions and the role of variables +delineating the partitions: + +(cid:16)(cid:18)(cid:16)(cid:18)(cid:16) + +(cid:16)(cid:18)(cid:16)(cid:18)(cid:16) + +(cid:16)(cid:18)(cid:16)(cid:18)(cid:16) + +The SML version of qsort using arrays is: + +(* qsort : char array -> int -> int -> char array *) +fun qsort data l r += if l >= r + +then data +else let + +val p += l +val data_p = sub (data, p) += l +val i +val j += r +val (data(cid:146), i(cid:146), j(cid:146)) + += partition p data_p data l i j r +l j(cid:146) += qsort data(cid:146) +i(cid:146) r += qsort data(cid:146) + +val data(cid:146) +val data(cid:146) + +in + +data(cid:146) + +end ; + +Revision: 6.33 + +(cid:11) +(cid:11) +(cid:0) +(cid:0) +(cid:12) +(cid:12) +(cid:0) +(cid:0) +(cid:0) +(cid:0) +(cid:146) +(cid:146) +(cid:146) +(cid:146) +(cid:146) +(cid:146) + 238 + +Chapter7. Streams + +The partition function receives the index position p of the pivot, the pivot itself +data_p, the input array data, the boundaries l and r of the section of the array to +be partitioned, and the initial values of i and j. The partition function returns +the data array with the elements between l and r partitioned, and it also returns +the boundaries of the new partitions as i(cid:146) and j(cid:146) +is passed to +a recursive qsort to order the elements between l and j(cid:146) +. The resulting array +data(cid:146) +is passed to the second recursive invocation of qsort. The latter orders +the elements between positions i(cid:146) and r and returns this result as data(cid:146) + +. The array data(cid:146) + +. + +, two indices i(cid:146) and j(cid:146) + +The C solution follows the functional solution closely, except where the call to +partition is concerned. Here the functional version returns, along with the new +array data(cid:146) +. A C function can be made to return a data +structure containing these elements, but it is not idiomatic C to do so. Instead, one +would pass the address of the variables i and j to the partition function so that it +may update these. The operator & is used to deliver the address of the variables. +The partition function already has a side effect (it updates the data array), so +nothing is lost by making it update the variables i and j as well. + +void qsort( char data [], int l, int r ) { + +if( l < r) { + +int p = l ; +char data_p = data[p] ; +int i = l ; +int j = r ; +partition( p, data_p, data, l, &i, &j, r ) ; +qsort( data, l, j ) ; +qsort( data, i, r ) ; + +} + +} + +The idea of an ef(cid:2)cient partitioning is to move the elements of the array by ex- +changing two elements at a time. This consists of a number of steps: + +up The up sweep starts at the left most position (initially l) and compares the el- +ements it (cid:2)nds with the pivot. It keeps moving to the right until an element +is found that is greater than the pivot. + +down The down sweep starts at the right most element of the partition (initially +r) and keeps moving to the left until an element is found that is less than the +pivot. + +swap While the up and down sweeps have not met, swap the last elements en- +countered by both up and down, as they are both in the wrong partition. +Restart the up sweep and down sweep from the next positions. + +stop The process stops as soon as the up and down phases meet. + +The (cid:2)gure below illustrates the partitioning process on a sample array of 7 ele- +ments (indexed by 0 to 6). + +Revision: 6.33 + +(cid:146) +(cid:146) +(cid:146) + 7.4. Quicksort + +239 + +step +1. + +2. + +3. + +4. + +5. + +6. + +7. + +8. + +9. + +[0] +‘E’ +i +‘E’ + +‘E’ + +[1] +‘C’ + +‘C’ +i +‘C’ + +‘E’ + +‘C’ + +‘E’ + +‘C’ + +‘E’ + +‘C’ + +‘E’ + +‘C’ + +‘E’ + +‘C’ + +[2] +‘F’ + +[3] +‘B’ + +[4] +‘A’ + +[5] +‘C’ + +‘F’ + +‘B’ + +���A’ + +‘C’ + +‘F’ +i +‘F’ +i +‘F’ +i +‘F’ +i +‘C’ +i +‘C’ + +‘B’ + +‘A’ + +‘C’ + +‘B’ + +‘A’ + +‘C’ + +‘C’ +j +‘C’ +j +‘F’ +j +‘F’ + +‘B’ + +‘A’ + +‘B’ + +‘A’ + +‘B’ + +‘A’ + +‘B’ +i +‘B’ + +[6] +‘G’ +j +‘G’ +j +‘G’ +j +‘G’ +j +‘G’ + +‘G’ + +‘G’ + +‘G’ + +‘E’ + +‘C’ + +‘C’ + +10. + +‘E’ + +‘C’ + +‘C’ + +‘B’ + +11. + +‘E’ + +‘C’ + +‘C’ + +‘B’ + +12. + +‘E’ + +‘C’ + +‘C’ + +‘B’ + +13. + +‘A’ + +‘C’ + +‘C’ + +‘B’ + +14. + +‘A’ + +‘C’ + +‘C’ + +‘B’ +j + +‘A’ +j +‘A’ +i,j +‘A’ +j +‘A’ +j +‘A’ +j +‘E’ +j +‘E’ + +‘F’ + +‘G’ + +‘G’ + +‘G’ + +‘G’ + +‘G’ + +‘G’ + +‘F’ +i +‘F’ +i +‘F’ +i +‘F’ +i +‘F’ +i + +‘E’ so j moves left + +‘E’ so i moves right + +‘E’ so i moves right + +‘E’ so i cannot be moved + +Comments +initial state +initial positions i=0 and j=6 +function up +‘E’ (cid:11) +function up +‘C’ (cid:11) +function up +‘F’ +function down +‘G’ +function down +‘E’ so j cannot be moved +‘C’ (cid:11) +function partition at i < j +the ‘F’ and the ‘C’ are swapped +function partition +i moves right, j moves left +function up +‘B’ (cid:11) +function up +‘A’ (cid:11) +function up +‘F’ +function down +‘E’ so j cannot be moved +‘A’ (cid:11) +function partition at p < j +exchange ‘E’ (pivot) and ‘A’ +function partition +move j one step further and stop + +‘E’ so i cannot be moved + +‘E’ so i moves right + +‘E’ so i moves right + +The partition function has to do a lot of work, so we should expect it to be +complicated. The code below exhibits the main structure, that is, an up sweep and +a down sweep precede the main decision making. The complications arise because +there are four separate cases to consider. The (cid:2)rst case continues the recursion +(when the up sweep and the down sweep have not met). The other three cases +terminate the recursion, depending on the value of the (cid:2)nal elements, the pivot +has to be swapped with either element, or no swap has to take place at all. In any +case the pivot element ends up ‘sandwiched’ between the two partitions. The SML +implementation reads: + +(* partition : int -> char -> char array -> + +int -> int -> int -> int -> +(char array * int * int) *) + +fun partition p data_p data l i j r + += let + +val i(cid:146) = up + +data_p data i r + +Revision: 6.33 + +, +, +, + 240 + +Chapter7. Streams + +val j(cid:146) = down data_p data l j + +in + +if i(cid:146) < j(cid:146) + +then partition p data_p (swap data i(cid:146) j(cid:146)) + +l (i(cid:146)+1) (j(cid:146)-1) r + +else if i(cid:146) < p + +then (swap data i(cid:146) p, i(cid:146)+1, j(cid:146)) +else if p < j(cid:146) + +then (swap data p j(cid:146), i(cid:146), j(cid:146)-1) +else (data, i(cid:146), j(cid:146)) + +end ; + +The structure of the partition function matches the requirements of the general +while-schema, so the C implementation is: + +void partition( int p, char data_p, char data[], +int l, int *i, int *j, int r ) { + +while( true ) { + +*i = up( +data_p, data, *i, r ) ; +*j = down( data_p, data, l, *j ) ; +if( *i < *j ) { + +swap( data, *i, *j ) ; +(*i)++ ; +(*j)-- ; + +} else if( *i < p ) { + +swap( data, *i, p ) ; +(*i)++ ; +return ; + +} else if( p < *j ) { + +swap( data, p, *j ) ; +(*j)-- ; +return ; + +} else { + +return ; + +} + +} + +} + +Using the pointers to i and j is slightly clumsy, this will be solved in Exercise 7.16. +The up and down functions sweep along the array and compare the elements to +the pivot. The up function stops when either it encounters the boundary r or it +encounters an element that exceeds the pivot. In SML: + +(* up : char -> char array -> int -> int -> int *) +fun up data_p data i r + += if i < r andalso sub (data, i) <= (data_p:char) + +then up data_p data (i+1) r +else i ; + +The up and down functions are symmetric: the down function sweeps downwards + +Revision: 6.33 + + 7.4. Quicksort + +241 + +until it encounters either the boundary l or an element that is less than the pivot: + +(* down : char -> char array -> int -> int -> int *) +fun down data_p data l j + += if l < j andalso sub (data, j) >= (data_p:char) + +then down data_p data l (j-1) +else j ; + +The up and down functions can be translated into pure C functions using the while +schema: + +int up( char data_p, char data[], int i, int r ) { + +while( i < r && data[i] <= data_p ) { + +i++ ; + +} +return i ; + +} + +int down( char data_p, char data[], int l, int j ) { + +while( l < j && data[j] >= data_p ) { + +j-- ; + +} +return j ; + +} + +These two functions use the short circuit semantics of the &&-operator: the right +hand operand is not evaluated if the left hand side evaluates to false. The ex- +pression in up that tests the loop termination checks whether the index i is within +the array bounds, before actually indexing in the array data. Consider the && +with its argument reversed: + +while( data[i] <= data_p && i < r ) + +Although the && operator is logically commutative, the result of this expression +might be different since the expression data[i] might cause the program to crash +before the bound check is performed. + +The array version of qsort is now complete. Here is a main program to call + +qsort on a small SML list: + +(* main : char array *) +val main = let + +val list = explode "ECFBACG" +val l +val r +val data = list_to_array list + += 0 += length list - 1 + +in + +qsort data l r + +end ; + +Here is the corresponding C version: + +int main( void ) { + +int l = 0 ; + +Revision: 6.33 + + 242 + +} + +int r = 6 ; +char data[] = "ECFBACG" ; +qsort( data, l, r ) ; +printf( "%s\n", data ) ; +return 0 ; + +Chapter7. Streams + +Exercise 7.16 The partition function is used only once in qsort. Substitute the +body of the C version of partition in that of qsort and show that this +removes the need for manipulating the address of the variables i and j. + +We have now two versions of quicksort: one to sort a list of characters and +one to sort an array of characters. Using the functions stream_to_list and +stream_to_array, it is easy to build a function that sorts the contents of a +stream. Such a function would not be useful, as one often is not interested in just +the sorted characters of a stream. It would be more interesting to sort the lines or +numbers contained in a stream. It is not dif(cid:2)cult to extend the quicksort versions +for such purposes. + +Exercise 7.17 Write a program that reads a (cid:2)le, and sorts it on a line by line basis. + +7.5 Summary + +The following C constructs were introduced: + +Streams The type to denote a stream in C is FILE *. The stream is stored exter- +nally, it can be input by the user, from another program, or from a (cid:2)le. A +stream is a linear sequence, like an array and a list, but it can usually only be +accessed sequentially. + +The main programming principles that we have seen in this chapter are: + +(cid:1) The re-use of volatile information, such as that accessed from a stream, re- +quires careful planning. Often, algorithms require the information from a +stream to be accessed a number of times. This is inef(cid:2)cient, and it pays off to +spend effort in trying to devise equivalent algorithms that glean the relevant +information from a stream whilst making a single pass. + +(cid:1) The primitives provided with the standard data types are often of a low +level of abstraction. In this chapter, we have built functions that provide a +buffered view of a stream. +It is often a good idea to invest in a collection +of building blocks (functions and data structures) that deliver additional ser- +vices, in this case buffering. In a sense, the buffering facilities mitigate one +of the restrictions that streams impose, the sequential access. Within certain +limits, the elements of a stream can be accessed in an order that is not quite +sequential. Enlarging the size of the buffer weakens the limited access to the + +Revision: 6.33 + + 7.6. Furtherexercises + +243 + +point where the buffer is capable of containing the entire stream. In that case +the sequential access restriction on the stream is completely hidden. The +price to pay for this (cid:3)exibility is an amount of store capable of holding the +entire contents of the stream. + +(cid:1) Side effects can be useful and allow for highly ef(cid:2)cient programs to be writ- +ten. However, a function that performs a side effect should advertise this, +because care must be taken when such a function is used as a building block. +Hidden side effects can lead to obscure errors. + +(cid:1) The open list technique has been used to develop an ef(cid:2)cient function for +reading the contents of a stream into a list. +It has also been used in our +implementation of the buffering technique. Here a separate data structure +maintains the pointers necessary to implement the open list technique. + +If two functions with a similar structure operate one after the other on the +same data structure, then these functions can often be merged. There is an +important tradeoff here: +the two individual functions are less specialised +and therefore better building blocks than the merged result. However, the +merged function is often more ef(cid:2)cient, because the data structure (for ex- +ample a stream) does not need to be stored. + +(cid:1) The quicksort algorithm has been presented in two forms. The (cid:2)rst version +is elegant but inef(cid:2)cient and uses lists. The inef(cid:2)ciency is caused entirely +by the pro(cid:3)igate use of store. To counter this misdemeanour an array based +version was developed. This version does not resemble the elegant list based +version in any way. The understanding obtained from the list based version +was used to good effect in the creation of the array based version. The ef(cid:2)- +ciency of the array based version is entirely attributable to the use and re-use +of the original array containing the data. + +7.6 Further exercises + +Exercise 7.18 The database of employees (Section 5.9 and Exercise 5.8) was stored +in memory. A real data base would be stored on a (cid:2)le. Design functions +which will allow the employee database to be stored on a (cid:2)le. Use the fol- +lowing (cid:2)le format: the members of the structure are terminated by hash +signs (#), each new structure starts on a new line. For example: + +John#18813#1963#80#90#75#20#69# +Mary#19900#1946#72#83#75#18#75# +Bob#12055#1969#120#110#100#99#99# +Alice#15133#1972#200#230#75#11#35# + +Exercise 7.19 Quicksort is not the only sorting method. Another method is bubble +sort. It compares every element in an array of data to every other element. +If two elements are out of order, then they are swapped. If there are +data + +Revision: 6.33 + +(cid:1) +(cid:15) + 244 + +Chapter7. Streams + +elements, bubble sort will always make +com- +parisons. Quicksort only makes this many comparisons in the worst case, +it makes fewer comparisons on average. Write a C function bubble_sort +and test it by sorting the list of strings supplied through argc and argv. + +(cid:16)(cid:18)(cid:16)(cid:21)(cid:16) + +Exercise 7.20 Modify one of the sorting functions from this chapter to sort strings +rather than characters. Then use your sort function to sort the lines of a (cid:2)le, +representing the contents of a line as a string. + +Exercise 7.21 Sensitive information is often encrypted such that it is dif(cid:2)cult for +unauthorised persons to intercept that information. An ancient method for +encryption is the Caesar cipher. If a letter in the original message or plaintext +is the +(cid:0) -th +-th letter of the character set then replace this letter by the +letter in the encrypted message or cipher text. The key to encrypting and +decrypting the message is then the number (cid:0) +. For example if the plain text +is (cid:147)Functional C(cid:148) and the key is 4, then the cipher text is (cid:147)Jyrgxmsrep$G(cid:148), +for the fourth letter after F is J, and so on. Write a program to implement +the Caesar cipher method, taking the text to be processed from stdin and +writing the output to stdout. The program should take a single argument: +for decryption. Would you be able to prove for all +that decryption after encryption is equivalent to do nothing at + +for encryption or (cid:0) + +values of (cid:0) +all, or, for people familiar with UNIX terminology: + +(a.out +k | a.out -k) = cat + +Exercise 7.22 The encryption of Exercise 7.21 is weak. If you know that the plain +text was written in, say, the English language, then you would expect the +most frequently occurring letter in the cipher text to represent the letter ‘e’, +since this is the most frequently occurring letter in English text. It should +thus not be dif(cid:2)cult to guess what the encryption key (cid:0) would be. Your +guess could be con(cid:2)rmed by also looking at the next most frequently oc- +curring letter and so on, to see if they all agree on the key value. Frequency +tables for many natural languages are widely available. Try to get hold of +such a table for your native language and write a program to analyse a ci- +pher text produced by your Caesar cipher program so as to discover the key +with as much certainty as possible. + +Revision: 6.33 + +(cid:15) +(cid:0) +(cid:0) +(cid:2) +(cid:15) +(cid:0) +(cid:6) +(cid:2) +(cid:2) +(cid:0) +(cid:0) +(cid:4) +(cid:0) +(cid:10) +(cid:4) +(cid:0) +(cid:15) +(cid:15) +(cid:2) +(cid:2) +(cid:0) +(cid:0) + c(cid:0) + +1995,1996 Pieter Hartel & Henk Muller, all rights reserved. + +Chapter 8 + +Modules + +All programs developed so far were small. They typically consisted of no more +than 10 functions. Real programs are larger (thousands of functions). Large pro- +grams must be designed in such a way that the code can easily be inspected, main- +tained, and reused. This process of organising is generally known as modularisa- +tion. + +Modules are parts of the program that perform some speci(cid:2)c function together. +During the design of a program, the solution is split into modules. These modules +use each other according to some well de(cid:2)ned interface. Once the interface and +the functionality of a module are de(cid:2)ned, modules can be inspected, designed, +compiled, tested, debugged, and maintained separately. Additionally, modules +can be reused in other programs where a similar functionality is required. + +SML has a sophisticated module mechanism. It is completely integrated with +the language. An SML structure is a collection of types and functions; a signature +describes the interface of a structure, and a functor operates on structures to cre- +ate a new structure. SML modules support everything mentioned above, with the +(cid:3)exibility of a polymorphic type system. + +The module mechanism of C is rather different. It is probably the most crude +module mechanism of any programming language. The C module mechanism +is implemented by a separate program, the C preprocessor. The C preprocessor +takes a C program and prepares it for the C compiler. This preprocessor has no +knowledge of the syntax of C, but handles the program as text instead (indeed, +the C preprocessor can be used for many other purposes). The C module mecha- +nism consequently lacks the sophistication of a real module system, as provided +by SML. + +The (cid:2)rst section of this chapter describes the basic structure of the C module +system, and henceforth, of the C preprocessor. After that, we discuss the con- +cept of global variables as an important aspect of modularisation. Global variables +can be used to store state information that remains accessible across function calls. +When used correctly, global variables can be an asset. However, it is easy to abuse +them and obscure code. We show how global state can be stored differently, lead- +ing to a cleaner interface. This is akin to an object oriented style of programming. +After this, we show how modules can also be generalised, by discussing the coun- +terpart of polymorphism. + +245 + + 246 + +Chapter8. Modules + +8.1 Modules in C: (cid:2)les and the C preprocessor + +The module concept of C is text oriented. The module facilities are implemented +by the C preprocessor. This is a program that is separate from the C compiler. As +far as the C preprocessor is concerned, it can process C programs, but it can pro- +cess an assembly language program or an HTML script equally well. The entity +on which the C preprocessor operates is the (cid:2)le. A (cid:2)le that is passed to the C com- +piler for compilation is (cid:2)rst processed by the C preprocessor. All lines that start +with a hash-sign # are interpreted as commands. Textual substitutions are made +where necessary throughout the entire (cid:2)le, substitution is not restricted to lines be- +ginning with a # sign. Below, we create a module that implements complex arith- +metic. After that, the features of the C preprocessor are explored in detail. + +8.1.1 Simple modules, #include + +As an example, we develop a module for arithmetic on complex numbers. A com- +plex number is de(cid:2)ned as follows: + +is the imaginary part of the complex number (cid:3) , (cid:0) + +is the real +Here (cid:0) +part of (cid:3) . Complex arithmetic works just like ordinary arithmetic, except that we +have to take care that (cid:0) is properly handled. Examples: + +(cid:0) , and (cid:3) + +(cid:8)(cid:16)(cid:1) + +Equality (8.2) is true because (cid:0) + +(cid:3)(cid:18)(cid:1) + +(cid:0) . + +(8.1) +(8.2) + +The implementation of complex subtraction and multiplication as functions in +SML is given below. The complex_distance function gives the distance from +the origin of the complex plane. + +structure Complex = struct + +type complex = real * real ; + +(* complex_sub : complex -> complex -> complex *) +fun complex_sub (r,s) (t,u) += (r-t,s-u) : complex ; + +(* complex_multiply : complex -> complex -> complex *) + +Revision: 6.38 + +(cid:0) +(cid:14) +(cid:3) +(cid:0) +(cid:2) +(cid:6) +(cid:3) +(cid:0) +(cid:0) +(cid:3) +(cid:0) +(cid:0) +(cid:0) +(cid:2) +(cid:3) +(cid:0) +(cid:0) +(cid:0) +(cid:0) +(cid:14) +(cid:3) +(cid:14) +(cid:1) +(cid:14) +(cid:0) +(cid:0) +(cid:2) +(cid:6) +(cid:3) +(cid:14) +(cid:25) +(cid:0) +(cid:0) +(cid:3) +(cid:0) +(cid:0) +(cid:0) +(cid:2) +(cid:3) +(cid:25) +(cid:0) +(cid:1) +(cid:0) +(cid:2) +(cid:0) +(cid:3) +(cid:0) +(cid:25) +(cid:0) +(cid:1) +(cid:0) +(cid:0) +(cid:2) +(cid:3) +(cid:8) +(cid:0) +(cid:1) +(cid:1) +(cid:0) +(cid:2) +(cid:0) +(cid:8) +(cid:0) +(cid:0) +(cid:0) +(cid:2) +(cid:3) +(cid:0) +(cid:1) +(cid:0) +(cid:0) +(cid:0) +(cid:0) +(cid:1) +(cid:0) +(cid:0) +(cid:1) +(cid:8) +(cid:0) +(cid:2) +(cid:1) +(cid:3) +(cid:0) +(cid:0) +(cid:8) +(cid:3) +(cid:25) +(cid:0) +(cid:1) +(cid:0) +(cid:0) +(cid:2) +(cid:3) +(cid:1) +(cid:0) +(cid:2) +(cid:0) +(cid:8) +(cid:0) +(cid:0) +(cid:0) +(cid:1) +(cid:0) +(cid:2) +(cid:0) +(cid:0) +(cid:0) +(cid:2) +(cid:0) +(cid:2) +(cid:3) +(cid:0) +(cid:0) +(cid:1) +(cid:0) +(cid:0) +(cid:2) +(cid:3) +(cid:1) +(cid:8) +(cid:0) +(cid:2) +(cid:1) +(cid:3) +(cid:0) +(cid:0) +(cid:0) +(cid:1) +(cid:8) +(cid:0) +(cid:0) +(cid:1) +(cid:0) +(cid:0) +(cid:0) +(cid:8) +(cid:0) +(cid:0) +(cid:0) + 8.1. ModulesinC: (cid:2)lesandtheCpreprocessor + +247 + +fun complex_multiply (r,s) (t,u) + += (r*u+s*t,s*u-r*t) : complex ; + +(* complex_distance : complex -> real *) +fun complex_distance (r,s) += sqrt (r*r+s*s) ; + +end ; + +The structure Complex is de(cid:2)ned containing a type complex, and the functions +to operate on complex numbers. These functions can be implemented in C as +shown below. The (cid:2)rst line imports the mathematics module that provides the +sqrt function. + +#include + +typedef struct { + +double im , re ; + +} complex ; + +complex complex_sub( complex c, complex d ) { + +complex r ; +r.im = c.im - d.im ; +r.re = c.re - d.re ; +return r ; + +} + +complex complex_multiply( complex c, complex d ) { + +complex r ; +r.im = c.im * d.re + d.im * c.re ; +r.re = c.re * d.re - d.im * c.im ; +return r ; + +} + +double complex_distance( complex c ) { + +return sqrt( c.im * c.im + c.re * c.re ) ; + +} + +To use these functions as a separate module, an interface to the module must be +de(cid:2)ned. The interface lists all functions and types that need to be accessible from +outside the module. The types are de(cid:2)ned as usual. For functions, the names and +types of the arguments and the result are given. In SML, the interface to a module +is a signature. Here is the signature of the complex number module: + +signature COMPLEX = sig + +type complex ; +val complex_sub +: complex -> complex -> complex ; +val complex_multiply : complex -> complex -> complex ; +val complex_distance : complex -> real ; + +end ; + +Revision: 6.38 + + 248 + +Chapter8. Modules + +An implementation is associated with this signature as follows: + +structure Complex : COMPLEX = struct + +type complex = real * real ; + +fun complex_sub (r,s) (t,u) += (r-t,s-u) : complex ; + +fun complex_multiply (r,s) (t,u) + += (r*u+s*t,s*u-r*t) : complex ; + +fun complex_distance (r,s) += sqrt (r*r+s*s) ; + +end ; + +The point of separating the interface of a module from its implementation is to be +able to maintain and use them separately. SML offers the construct sig. . . end +to encapsulate an interface and the construct struct . . . end to encapsulate the +implementation. The programmer has the option of storing them in separate (cid:2)les +or keeping them together. In C, this is not the case: an interface must be stored +separately from an implementation. + +In C, the interface to a module is stored in a header (cid:2)le. The information it con- +tains is similar to the signature of SML. The de(cid:2)nition of a function in the header +(cid:2)le is known as the prototype of the function. It consists of the result type of the +function, its name, and the types of its arguments. Here is the interface to the C +version of the complex number module: + +typedef struct { + +double im , re ; + +} complex ; + +extern complex complex_sub( complex c, complex d ) ; +extern complex complex_multiply( complex c, complex d ) ; +extern double complex_distance( complex c ) ; + +The interface gives the type complex and the prototypes of the three functions +that operate on values of that type. The word extern before the function decla- +ration indicates that these three functions can be considered as external functions +by any module using the complex module. The interface must be stored in a sepa- +rate (cid:2)le. By convention, this (cid:2)le has a name that ends with a .h suf(cid:2)x (for header). +The implementation of the functions is then stored in a (cid:2)le named with a .c suf(cid:2)x. +Thus we could store the interface above in the (cid:2)le complex.h. The implementa- +tion of the functions would be found in the (cid:2)le complex.c: + +#include +#include "complex.h" + +complex complex_sub( complex c, complex d ) { + +complex r ; +r.im = c.im - d.im ; + +Revision: 6.38 + + 8.1. ModulesinC: (cid:2)lesandtheCpreprocessor + +249 + +r.re = c.re - d.re ; +return r ; + +} + +complex complex_multiply( complex c, complex d ) { + +complex r ; +r.im = c.im * d.re + d.im * c.re ; +r.re = c.re * d.re - d.im * c.im ; +return r ; + +} + +double complex_distance( complex c ) { + +return sqrt( c.im * c.im + c.re * c.re ) ; + +} + +Note that the type de(cid:2)nition has disappeared from the code and has been replaced +by the following line: + +#include "complex.h" + +The #include directive tells the compiler to literally include the (cid:2)le complex.h +at this place in the program. The type de(cid:2)nition and the prototypes are imported +by the C preprocessor. The C compiler will verify that the prototype of each func- +tion that is exported is consistent with the implementation. + +The #include directive has been introduced earlier, in Chapter 2, where it +was used it to import the module performing input and output. Indeed the state- +ment below imports the interface of the module stdio: + +#include + +The name stdio is short for ‘standard input and output’. We write the (cid:2)lename +between the angular brackets < and >, instead of the double quotes shown around +"complex.h", because stdio.h is a standard library. The names of header (cid:2)les +that do not belong to the standard library should be enclosed in double quotes. +Similarly, the header (cid:2)le math.h has to be included, which allows the program to +use the function sqrt. + +Any C module that uses the complex number module should have a line that +imports the complex number interface. As an example, consider a main program +to calculate the square of a complex number and then subtract the square from the +number itself: + +#include +#include "complex.h" + +complex complex_square( complex x ) { +return complex_multiply( x, x ) ; + +} + +void complex_print( complex x ) { + +printf( "(%f+%fi)", x.re, x.im ) ; + +} + +Revision: 6.38 + + 250 + +Chapter8. Modules + +int main( void ) { + +complex x = { 2.0, 1.0 } ; +complex y = complex_square( x ) ; +complex z = complex_sub( x, y ) ; +complex_print( y ) ; printf( "\n" ) ; +complex_print( z ) ; printf( "\n" ) ; +return 0 ; + +} + +The main program and the complex number module can be compiled separately. +The interface of the complex number module in the (cid:2)le complex.h links these +two together. To make this link explicit, complex.h speci(cid:2)es all types and func- +tions of complex.c that are to be used by any other module. +In this exam- +ple, complex.h only speci(cid:2)es the type of only a single struct-de(cid:2)nition, but +in other cases it might require the de(cid:2)nition of enumerated types, unions, and +#defines. + +8.1.2 Type checking across modules + +The module system is the Achilles heel of the C type system; it is important that +the C programmer is aware of this weakness so to avoid common mistakes. As +described so far, the typing system is safe (that is if certain C features, such as +void *, type casts and variable argument list are not used). If the prototype of +a function speci(cid:2)es three arguments of certain types, the compiler will not accept +a call with any other number of arguments or with the wrong types. There are, +however, two weaknesses: + +1. What if there is no prototype? + +2. Can the compiler verify that the prototype is correct? + +The (cid:2)rst problem is caused by backward compatibility of ISO-C with C. Any func- +tion that is called for which no prototype has been declared is assumed to be a +function returning an integer number, and no checking of any kind is performed +on the argument list. This means that if one forgets to include a header (cid:2)le, the +compiler will not complain about using unde(cid:2)ned functions, but will simply as- +sume that these functions return an integer. Most of the time the compilation will +fail because of some other problem. If, for example, the module complex.h is not +included, the type complex is not de(cid:2)ned, which will result in an error. How- +ever, a classic error is not to include the (cid:2)le math.h when using the mathematical +library. When calling the function sin(x) or sqrt(x), the compiler will silently +assume that these function return an integer. The results are dramatic. Most mod- +ern compilers will (on request) inform the programmer about missing prototypes. +for example +complex.h, is included, the compiler must assume that the speci(cid:2)cation is cor- +rect. The correctness of this speci(cid:2)cation is veri(cid:2)ed when complex.c is compiled. +So far so good, but if the programmer forgets to include complex.h in the source + +The second problem is also interesting. When a module, + +Revision: 6.38 + + 8.1. ModulesinC: (cid:2)lesandtheCpreprocessor + +251 + +complex.c, these checks are not performed. Again, the compiler will usually (cid:2)nd +some other error, for example, because the type complex has not been de(cid:2)ned. +Modules that do not de(cid:2)ne types may compile without problem though. Most +modern compilers will warn the programmer on request when a function is used +that was not prototyped. This warning catches 99% of the errors that arise because +of improper use of the module facility. + +Both problems are due to the looseness of the module system of C. Languages +like Modula-2 and SML do not suffer from these problems, since their module sys- +tems were designed to be watertight. + +8.1.3 Double imports + +In large programs, one often needs the interface to one module whilst building +the interface to another module. For example, a module with graphics primitives +might rely on a module de(cid:2)ning matrices, vectors, and the associated arithmetic. +In turn, these modules might depend on other module interfaces. + +As in SML, C allows module interfaces to be imported in interfaces. However, +the C module system relies on the programmer to do so correctly. As a (cid:2)rst exam- +ple, suppose that the graphics module uses matrices and vectors. Therefore, the +header (cid:2)le of the graphics module reads: + +#include "vector.h" +#include "matrix.h" +/*C graphics function prototypes*/ + +The matrix package in turn needs a de(cid:2)nition of vectors, in order to supply oper- +ations to multiply a matrix and a vector: + +#include "vector.h" + +typedef struct { + +vector *columns ; +int coordinates ; + +} matrix ; +extern matrix matrix_multiply( matrix x, matrix y ) ; +extern vector matrix_vector( matrix x, vector y ) ; + +Finally, the vector header (cid:2)le de(cid:2)nes some type for a vector: + +typedef struct { + +double *elements ; +int coordinates ; + +} vector ; +extern double vector_multiply( vector x, vector y ) ; +extern vector vector_add( vector x, vector y ) ; + +When the interface of the graphics module is used somewhere, the C preproces- +sor will expand all include directives to import all types and primitives. This will +result in the following collection of C declarations: + +typedef struct { + +/*Lines imported by graphics.h*/ + +Revision: 6.38 + + 252 + +Chapter8. Modules + +double *elements ; +int coordinates ; + +} vector ; +extern double vector_multiply( vector x, vector y ) ; +extern vector vector_add( vector x, vector y ) ; + +typedef struct { + +/*Lines imported via matrix.h*/ + +double *elements ; +int coordinates ; + +} vector ; +extern double vector_multiply( vector x, vector y ) ; +extern vector vector_add( vector x, vector y ) ; + +typedef struct { + +/*Lines imported by graphics.h*/ + +vector *columns ; +int coordinates ; + +} matrix ; +extern matrix matrix_multiply( matrix x, matrix y ) ; +extern vector matrix_vector( matrix x, vector y ) ; + +/*C graphics function prototypes*/ + +Note that the header (cid:2)le vector.h has been included twice. Because the C mod- +ule mechanism is entirely text-based, the C preprocessor has no objections against +including a header (cid:2)le twice. This double inclusion causes the compiler to (cid:3)ag an +error, because the types are de(cid:2)ned twice. To avoid double inclusion, header (cid:2)les +must explicitly be protected. This protection can be implemented by means of an +#ifndef directive, which conditionally includes text. A proper header (cid:2)le for the +vector module would be: +#ifndef VECTOR_H +#define VECTOR_H + +typedef struct { + +double *elements ; +int coordinates ; + +} vector ; + +extern double vector_multiply( vector x, vector y ) ; +extern vector vector_add( vector x, vector y ) ; + +#endif /* VECTOR_H */ + +This header (cid:2)le should be read as follows: +the part of text enclosed by +the #ifndef VECTOR_H and #endif will only be compiled if the identi(cid:2)er +VECTOR_H is not de(cid:2)ned (#ifndef stands for ‘if not de(cid:2)ned’). +Thus, the +(cid:2)rst time that this header (cid:2)le is included, the program text in it, starting with +#define VECTOR_H and ending with the prototype of vector_add, will be in- + +Revision: 6.38 + + 8.1. ModulesinC: (cid:2)lesandtheCpreprocessor + +253 + +cluded. This code actually de(cid:2)nes VECTOR_H, so the next time that the header (cid:2)le +is included, the code will not be included. This is a low level mechanism indeed, +but it does the trick. + +The C module mechanism really breaks down when names of functions of var- +ious modules clash. All functions of all modules essentially share the same name +space. This means that no two functions may have the same name. +It is good +practice to ensure that function names are unique and clearly relate to a module, +in order to prevent function names clashing. The complex number module at the +beginning of this chapter uses names of the form complex_ (cid:16)(cid:18)(cid:16)(cid:18)(cid:16) to indicate that +these belong to the complex number module. + +8.1.4 Modules without an implementation + +The modules that we have seen so far have an implementation and an interface. +Not all modules need an implementation; a module may consist of only an inter- +face. As an example, we can de(cid:2)ne a module for the booleans as follows: + +#ifndef BOOL_H +#define BOOL_H + +typedef enum { false = 0 , true = 1 } bool ; + +#endif /* BOOL_H */ + +This module only exports a type, and it has no corresponding source (cid:2)le. From +now on, we will import the module bool.h when booleans are needed. + +Like the vector module, the interface of the boolean module has been protected + +against multiple inclusion, using a #ifndef and #define. + +8.1.5 The macro semantics of #define directives + +The #define mechanism is used for other purposes than for preventing the mul- +tiple inclusion of header (cid:2)les. In Chapter 5, we saw that constants can be de(cid:2)ned +using a #define. In general, #define associates an identi(cid:2)er with a (possibly +empty) sequence of characters: + +#define monkeys + +42 gorillas and 12 gibbons + +This +iden- +ti(cid:2)er monkeys by the text 42 gorillas and 12 gibbons everywhere in the +program text after this de(cid:2)nition. This mechanism can be abused by de(cid:2)ning, for +example: + +replaces + +the + +#define BECOMES +#define INCREMENT ++ + += + +Now we can write i INCREMENT instead of i++, or i BECOMES 13 instead of +i = 13. This will make the code guaranteed unreadable for anyone but the origi- +nal author. Because replacement of identi(cid:2)ers is textual, the scoping rules of the C +grammar are ignored by the C preprocessor. This means that #define statements + +Revision: 6.38 + + 254 + +Chapter8. Modules + +inside a function have a global effect. Another consequence is that seemingly log- +ical #define directives do not have the desired effect. Consider the following +program fragment with three #define directives: + +#define x +#define y +#define z +int q = z ; + +4 +x+x +y*y + +In this example, occurrences of x are replaced by 4, occurrences of y are replaced +by 4+4, and occurrences of z are replaced by 4+4*4+4. So x=4, y=8, and z=24, +and not 64, as one might have expected. To prevent this kind of error, expressions +named using a #define should always be parenthesised: + +#define x +#define y +#define z +int q = z ; + +(4) +(x+x) +(y*y) + +The de(cid:2)nitions above result in the value 64 for z. Note that the parentheses +around the 4 are actually not necessary, as 4 will always be interpreted as 4. +Parentheses around numbers are often omitted. + +The #define can be used with arguments. The arguments are placed in paren- +theses after the identi(cid:2)er to be de(cid:2)ned (spaces between the identi(cid:2)er and the +parentheses are illegal). An identi(cid:2)er de(cid:2)ned in this way is known as a macro. +When an occurrence of the macro is replaced by its value, the arguments are sub- +stituted textually. As an example, consider the following de(cid:2)nition, which uses +the ternary conditional expression (cid:16)(cid:21)(cid:16)(cid:18)(cid:16) ? (cid:16)(cid:18)(cid:16)(cid:21)(cid:16) : (cid:16)(cid:18)(cid:16)(cid:18)(cid:16) (de(cid:2)ned in Section 2.2.5): + +#define min(x,y) + +( (x)<(y) ? (x) : (y) ) + +This states that wherever the call min( . . . , . . . ) is found, the following text +should appear instead: + +( (x)<(y) ? (x) : (y) ) + +All occurrences of x and y are replaced by the (cid:2)rst and second argument of min. +Thus, the text min((cid:146)p(cid:146),(cid:146)q(cid:146)) +will be replaced by: +(((cid:146)p(cid:146))<((cid:146)q(cid:146))?((cid:146)p(cid:146)):((cid:146)q(cid:146))) + +Evaluating this expression yields (cid:146)p(cid:146) +, which is indeed the smallest of the two +characters. The parentheses around x and y are necessary to ensure that argu- +ment substitution does not result in unexpected answers. However, despite the +parentheses, this macro still exhibits peculiar semantics. Consider the following +example: + +min( (cid:146)p(cid:146), + +getchar() ) + +This should intuitively return the minimum of the character (cid:146)p(cid:146) +and the next +character on the input stream. Unfortunately, this is not the case, as the textual +substitution results in the following expression: + +( ((cid:146)p(cid:146))<( + +getchar() ) ? ((cid:146)p(cid:146)) + +: ( getchar() ) ) + +Revision: 6.38 + + 8.2. Compiling modules + +255 + +The conditional (cid:2)rst calls getchar and checks if the value is greater than (cid:146)p(cid:146) +. If +. If it is not the case, getchar +this is the case, the value of the expression is (cid:146)p(cid:146) +is called again, which has a side effect.. This causes the (cid:2)nal value to be the second +character on the input stream (which may or may not be greater than (cid:146)p(cid:146) +). How- +ever, the macro min above does have an advantage over the following function +minf: + +int minf( int x, int y ) { +return x < y ? x : y ; + +} + +The function minf works only if both arguments are of the type int. However, the +macro min works on any combination of types. The term that is used to describe +this behaviour is that in C macros are polymorphic, while functions are specialised +for certain argument types. + +Although polymorphism can be a good reason to use macros, the programmer +should be aware that a macro cannot be passed to a higher order function. (Re- +member that macros are textually substituted). Macros can be quite useful, but +they have to be used with care. + +8.2 Compiling modules + +The C language has been designed so that modules can be compiled separately. +That is, the compiler can compile one module without knowledge of the imple- +mentation of any of the other modules. The header (cid:2)les provide the necessary +information about the interfaces of the other modules. Therefore, if the code of +one module is changed, only that module needs to be recompiled. The code from +all other modules stays the same. This shortens the development cycle of a C pro- +gram, as only small parts of programs need to be recompiled. + +If one of the header (cid:2)les is changed (for example, because the argument list +of a function has been changed), each module that imports the changed header +(cid:2)le needs to be recompiled. This is necessary for the compiler to verify that the +changed interface is still used correctly. If a module is not recompiled, it might +lead to a runtime error. Because it is hard to remember which modules need to +be compiled upon a change, most development environments offer a facility to +recompile all modules that are dependent on a changed interface. + +8.2.1 Separate compilation under UNIX + +UNIX C-compilers have a command line option to tell them that a module must be +compiled separately. This means that the compiler will not generate an executable, +but it will generate an object-(cid:2)le. As an example, we can compile the source code +of the module vector above by: + +cc -c vector.c + +Revision: 6.38 + + 256 + +Chapter8. Modules + +The -c option means ‘compile this module only’. The C compiler will generate +an object-(cid:2)le and store this under the name vector.o. Filenames ending with +.o are object (cid:2)les. When modules are compiled separately, a (cid:2)nal stage is needed +which generates an executable, given a number of object-(cid:2)les. This stage is called +the linking process. In order to link three objects (cid:2)les, say vector.o, matrix.o +and graphics.o, we call the C-compiler without the -c option. Because the ar- +guments are object (cid:2)les (recognised by their .o suf(cid:2)xes), the compiler will link +the modules together in one binary. In the example below, we have passed the -o +option to give the binary a meaningful name: + +cc vector.o matrix.o graphics.o -o graphics + +So all the programmer has to do in order to generate an executable is compile all +modules that need compilation, and to link the binaries together. The following +sequence of commands would achieve this on a UNIX system: + +cc -c vector.c +cc -c matrix.c +cc -c graphics.c +cc vector.o matrix.o graphics.o -o graphics + +These statements will compile all modules and link the binaries. Because typing +these commands and remembering precisely which modules need to be compiled +is an error-prone and tedious process, UNIX supplies a tool which does the work, +make. When invoked, make recompiles all modules that need to be recompiled. It +needs a (cid:2)le that speci(cid:2)es what to make and how to make it; this (cid:2)le is known as +the make (cid:2)le and is usually called makefile or Makefile. + +Basic make (cid:2)les + +The make (cid:2)le speci(cid:2)es how certain targets can be made, given certain dependencies. +The targets are the (cid:2)les that are generated by make. The dependencies are the (cid:2)les +used in the process of making a target. An example target is the (cid:2)le graphics, +while example dependencies are the (cid:2)les vector.c and vector.h. + +As a (cid:2)rst rule for the make (cid:2)le, we are going to state how to generate the target + +vector.o: + +vector.o: + +cc -c vector.c + +These two lines tell make that the target vector.o can be made by executing +the command cc -c vector.c. (A low level but important note for the reader: +the line with cc should start with a tabulate-character; make will fail if the line +starts with 8 spaces instead!) What this fragment of code lacks is the information +when vector.o needs to be made. There are two possible reasons why vector.c +should be recompiled: + +1. We have changed something in the program. + +That is, something in + +vector.c has been modi(cid:2)ed. + +Revision: 6.38 + + 8.2. Compiling modules + +257 + +2. We have changed something in the interface (vector.h). Although compi- +lation is not necessary to generate new object-code, it is necessary to verify +that the source (cid:2)le and the header (cid:2)le are consistent. + +In make terminology, vector.c and vector.h are dependencies of the tar- +get vector.o. Dependencies can be speci(cid:2)ed in the make(cid:2)le by a line +target: dependency. Therefore, the example makefile can be completed by +adding the two dependencies: + +vector.o: + +cc -c vector.c + +vector.o: vector.c +vector.o: vector.h + +The (cid:2)rst of the two dependencies speci(cid:2)es that if vector.c has changed (the +code of the program was modi(cid:2)ed), then the module must be recompiled. The +second dependency speci(cid:2)es that if vector.h has changed (the header (cid:2)le was +updated), the module also needs recompilation. Dependencies can be given on +separate lines, but one can also state multiple dependencies on a single line. The +last two lines can be replaced by one line: +vector.o: vector.c vector.h + +This shortens the make (cid:2)les a bit if there are many dependencies. It is also possible +to merge the dependencies with the rule for generating the target: + +vector.o: vector.c vector.h + +cc -c vector.c + +The dependencies are conveniently displayed in a picture, known as a depen- +dency graph. The picture below shows three boxes. The two boxes on the right +hand side denote the dependencies (vector.h and vector.c), the box on the +left hand side shows the target (vector.o), the arrows show the dependencies +(vector.o depends on both vector.c and vector.h), and the line in italics +shows the command that is used to generate the target: + +cc -c vector.c + +vector.o + +vector.c + +vector.h + +The module vector had only two dependencies, the header (cid:2)le and the code (cid:2)le. +The module matrix has more dependencies. matrix includes the header (cid:2)les +matrix.h and vector.h. Thus matrix must be compiled if either matrix.c is +updated (the code of the matrix module), if matrix.h is changed (to verify that +the header still matches with the code (cid:2)le), or if vector.h is updated (to verify +that the use of the vectors complies with the changed de(cid:2)nition). The part of the +makefile that speci(cid:2)es how to compile the module matrix is: + +matrix.o: matrix.c matrix.h vector.h + +cc -c matrix.c + +Revision: 6.38 + + 258 + +Chapter8. Modules + +There are now three dependencies, +matrix.o needs to be recompiled if vector.h has been updated. + +the last one explaining that the target + +The two parts of the make (cid:2)le for the modules vector and matrix can +now be concatenated to one makefile, specifying how to compile vector and +matrix. This combined makefile is shown below. We have placed multiple de- +pendencies on a single line: + +vector.o: vector.c vector.h + +cc -c vector.c + +matrix.o: matrix.c matrix.h vector.h + +cc -c matrix.c + +The dependency graph for this make (cid:2)le is: + +cc -c vector.c + +vector.o + +cc -c matrix.c + +matrix.o + +vector.c + +vector.h + +matrix.c + +matrix.h + +Note that there are two arrows pointing to the (cid:2)le vector.h. +updated then both modules vector and matrix have to be recompiled. + +If vector.h is + +The third module that was used was graphics. The module graphics in- +cludes the header (cid:2)les for matrix.h, vector.h, and graphics.h. Creating the +rules for graphics is left as an exercise to the reader. + +Exercise 8.1 Give the rules for the makefile that would describe how to compile + +the module graphics. + +Exercise 8.2 Integrate the rules of exercise 8.1 with the previous makefile (that +speci(cid:2)ed how to compile the modules vector and matrix) and draw the +dependency graph. + +So far, this example has explained how and when modules are to be compiled. +What is missing is the linking stage. The rule for how to link the modules, assum- +ing that the (cid:2)nal binary is called graphics, is: + +graphics: + +cc -o graphics vector.o matrix.o graphics.o + +We must also state when graphics must be linked. +In this case, the target +graphics must be made when either of the three dependencies vector.o, +matrix.o or graphics.o has changed. The dependencies are: + +graphics: vector.o matrix.o graphics.o + +Revision: 6.38 + + 8.2. Compiling modules + +259 + +Note that each of these three is a actually target of a previous rule! This is shown +when we integrate all parts of the make (cid:2)le: + +graphics: vector.o matrix.o graphics.o + +cc -o graphics vector.o matrix.o graphics.o + +vector.o: vector.c vector.h + +cc -c vector.c + +matrix.o: matrix.c matrix.h vector.h + +cc -c matrix.c + +graphics.o: graphics.c graphics.h matrix.h vector.h + +cc -c graphics.c + +The complete dependency graph can be derived from the makefile: + +cc -c graphics.c + +graphics.o + +cc -o graphics ... + +cc -c vector.c + +graphics + +vector.o + +cc -c matrix.c + +matrix.o + +graphics.c + +graphics.h + +vector.c + +vector.h + +matrix.c + +matrix.h + +The fact that vector.o is both a target (of the rule that speci(cid:2)ed how to compile +the module vector) and a dependency (of the rule that speci(cid:2)ed how to link the +program) is shown here as a box that has both inward and outward arrows. + +The order of rules in the make(cid:2)le is irrelevant but for one exception: the rule + +that is speci(cid:2)ed at the top speci(cid:2)es the target that will be made by default. + +The dependency graph is used by make to (cid:2)nd out which modules need to be +recompiled. As an example, assume that the (cid:2)le matrix.c was updated recently. +By tracing the dependencies backwards, make can deduce that it must remake +matrix.o and graphics. What is more, they must be made in that order. This +process of following the dependencies is shown below. The targets graphics and +matrix.o in the grey boxes need to be remade. + +Revision: 6.38 + + 260 + +Chapter8. Modules + +cc -c graphics.c + +graphics.o + +cc -o graphics ... + +cc -c vector.c + +graphics + +vector.o + +cc -c matrix.c + +matrix.o + +graphics.c + +graphics.h + +vector.c + +vector.h + +matrix.c + +matrix.h + +Exercise 8.3 Use the dependency graph to determine which (cid:2)les need to be re- + +compiled when matrix.h is changed. + +Default rules + +It is permitted to omit the rule for certain targets. In this case, the make program +uses default rules to decide how to make the target. In order to (cid:2)nd out how to +generate a target, make will use the (cid:2)le-suf(cid:2)x of the target. Given the (cid:2)le-name +suf(cid:2)x, make will search for a default rule that speci(cid:2)es how to make a target. + +One of the built-in default rules of make is that any (cid:2)le ending with .o can +be generated by invoking the C-compiler on a corresponding .c (cid:2)le. Other rules +state how Fortran or Pascal programs can be compiled. The advantage of this facil- +ity is twofold: the make (cid:2)le becomes shorter (now only giving dependencies and +the (cid:2)nal target rule) and the programmer does not have to worry about the precise +compiler options anymore. Our example make(cid:2)le would be reduced to: + +graphics: vector.o matrix.o graphics.o + +cc -o graphics vector.o matrix.o graphics.o + +vector.o: vector.c vector.h +matrix.o: matrix.c matrix.h vector.h +graphics.o: graphics.c graphics.h matrix.h vector.h + +Although the rules for compilation can be omitted, the dependencies must still be +speci(cid:2)ed. You can create your own default rules in make(cid:2)les, but that subject is +beyond the scope of this text. The interested reader is referred to the appropriate +UNIX manual pages. + +Abbreviations + +In the example make (cid:2)le, some text fragments are repeated. As an example, the +list of objects that are needed to build the whole program is speci(cid:2)ed twice: + +Revision: 6.38 + + 8.2. Compiling modules + +261 + +graphics: vector.o matrix.o graphics.o + +cc -o graphics vector.o matrix.o graphics.o + +The (cid:2)rst line lists the objects in the dependencies; the second lists the objects as +part of the rule how to make graphics. Listing such a set more than once is not +only tedious, but it also increases the likelihood of making errors. For this reason, +make has an abbreviation facility. (The of(cid:2)cial make terminology is ‘macro’, but +we use abbreviation in this text in order to distinguish them from macros in C.) A +text fragment (cid:0) + +can be given a name + +as follows: + += (cid:0) + +While before we had to cut and paste the text fragment, we can now write $( +This will be replaced by the text fragment associated with + +, (cid:0) + +: + +). + +OBJECTS=vector.o matrix.o graphics.o +graphics: $(OBJECTS) + +cc -o graphics $(OBJECTS) + +Here OBJECTS is used as an abbreviation for the following text: + +vector.o matrix.o graphics.o + +The string $(OBJECTS) is replaced by the de(cid:2)nition every time it is encountered. +There are many standard abbreviations. As an example, CFLAGS is used to de- +note any (cid:3)ags that are to be passed to the C compiler by the built-in rule for com- +piling a C module. The line below could be inserted in any make (cid:2)le: + +CFLAGS=-O + +This causes the -O (cid:3)ag to be passed to the C compiler (asking the compiler to op- +timise the code, investing extra time to make the code faster). Another built-in +abbreviation is CC which is an abbreviation of the name of the C-compiler. Nor- +mally CC equals cc, but on certain systems where the C-compiler has a different +name, the abbreviation will point to a different compiler. A typical use of the CC +abbreviation might be to use the GNU C compiler from the Free Software Founda- +tion: + +CC=gcc + +Making dependencies + +The program make is convenient to use, provided the make (cid:2)le is correct. If the +user makes a mistake in the make (cid:2)le, make will not recompile modules when +they should be recompiled. This can lead to disastrous results (especially since the +linker of C is not fussy at all about inconsistencies). Suppose that the following +dependency had been missed out: + +matrix.o: vector.h + +In this case, a change in the interface of the vector module will not lead to recom- +pilation of matrix. + +To prevent these errors, a utility program is available that (cid:2)nds out which de- +pendencies exist between various C modules. This program, called makedepend, +reads a number of C source modules and generates all the dependencies that exist + +Revision: 6.38 + +(cid:4) +(cid:4) +(cid:4) +(cid:4) + 262 + +Chapter8. Modules + +between these modules. In its simplest form, makedepend is just invoked with all +the source modules involved. It will generate all the dependencies and write them +in the make (cid:2)le. As an example, consider the following make (cid:2)le: + +OBJECTS=vector.o matrix.o graphics.o +graphics: $(OBJECTS) + +cc -o graphics $(OBJECTS) + +The (cid:2)rst goal speci(cid:2)es how graphics is to be made; there are no dependencies. +We can now type the following command: + +makedepend graphics.c vector.c matrix.c + +This will cause makedepend to (cid:2)nd all dependencies for these three source (cid:2)les +and to write them at the end of the make (cid:2)le. The resulting make (cid:2)le is: + +OBJECTS=vector.o matrix.o graphics.o +graphics: $(OBJECTS) + +cc -o graphics $(OBJECTS) + +# DO NOT DELETE THIS LINE -- make depend depends on it. + +graphics.o: graphics.c graphics.h vector.h matrix.h +vector.o: vector.c vector.h +matrix.o: matrix.c matrix.h vector.h + +The line starting with the #-sign is a comment line in the make (cid:2)le, makedepend +inserts it so that on the next run it can throw all old dependencies away. The +three lines after the comment line state precisely which modules depend on each +other. Every time the user changes something in the way that modules inter- +act, makedepend should be run to update the make (cid:2)le. One can make a target +‘depend’ in the make (cid:2)le, so that typing make depend makes the dependencies: + +depend: + +makedepend graphics.c vector.c matrix.c + +The complete make (cid:2)le for the graphics system is: + +CFLAGS=-O +OBJECTS=vector.o matrix.o graphics.o + +graphics: $(OBJECTS) + +cc -o graphics $(OBJECTS) + +depend: + +makedepend graphics.c vector.c matrix.c + +# DO NOT DELETE THIS LINE -- make depend depends on it. + +graphics.o: graphics.c graphics.h vector.h matrix.h +vector.o: vector.c vector.h +matrix.o: matrix.c matrix.h vector.h + +Revision: 6.38 + + 8.3. Globalvariables + +263 + +As long as there is no (cid:2)le named depend the rule for depend will always +be executed when requested. For more advanced information on make and +makedepend the reader is referred to the manual pages of these two programs. + +8.2.2 Separate compilation on other systems + +The reader may at this moment exclaim (cid:147)This is one big kludge! Each loophole +is patched with another loophole(cid:148). This statement is true to a certain extent. The +reason why it seems to be a system of patches on patches is that the UNIX design +philosophy (where make, C, and many other tools stem from) states that all tools +should be as reusable as possible. + +This was a revolutionary idea in the early seventies. The program make can be +used to compile any language, not just C. It can compile Fortran programs, make a +new UNIX kernel, or be used to decide which chapters of a book need to be type- +set. Similarly, UNIX offered one editor that was used for all purposes; furthermore +the C preprocessor is, as we have seen before, to a large extent C independent. The +advantage is that one has one big toolbox containing many (semi-)general purpose +tools. + +The disadvantage of this approach is that it is not user friendly at all. Given +the set of C modules that constitute a C program, the compiler could itself decide +which modules to recompile, without needing a make (cid:2)le or make (cid:2)le-generator. +This is more user friendly. Indeed, this is the approach taken by many C devel- +opment environments running on Macintoshes or modern PCs. Internally, these +environments have an editor, a make facility, a tool to work out which dependen- +cies exist, a C preprocessor, a compiler, and a linker, but the subtle differences are +hidden from the user. Additionally, an integrated editor allows the editor to check +the syntax of the program and can highlight compiler errors in the source code. + +Many of these development environments exist; most of these have built-in fa- +cilities to recompile only those modules that need recompilation. It is impossible +to address all these systems in detail. The reader is referred to the appropriate +documentation for the system of interest. + +8.3 Global variables + +All functions that have been de(cid:2)ned so far are functions that operate on values +Imperative languages have another place where +provided via their arguments. +data can be stored known as global variables. Global variables can ‘remember’ data +between function calls. When used with care, global variables can be an asset. +However, it is often better to use explicit global state, which is not hidden in global +variables. As an example, we will develop a pseudo random number generator. + +8.3.1 Random number generation, how to use a global variable + +Random numbers are often used in simulation programs, where a random choice +is to be made. True random numbers cannot be generated by a program, but good + +Revision: 6.38 + + 264 + +Chapter8. Modules + +pseudo random numbers can be computed. A widely used algorithm is the linear +congruential method, which uses the sequence: + +(cid:14)(cid:16)(cid:12)(cid:7)(cid:14) + +(cid:12)(cid:7)(cid:14) + +(cid:18)! #" + +if (cid:0) + +and + +If +primitive root of +and + +are carefully chosen ( +), the numbers (cid:8) + +should be a +(cid:16)(cid:18)(cid:16)(cid:21)(cid:16) will traverse all numbers between 1 +(cid:0) and +(cid:0)(cid:3)(cid:0) , then the sequence of generated numbers is (reading from left to right, top + +inclusive in a seemingly random order. As an example, let + +should be a prime number and + +(cid:8)(cid:10)(cid:2) + +to bottom): + +(cid:0)(cid:5)(cid:0) + +(cid:6)(cid:3)(cid:2) + +(cid:6)(cid:5)(cid:9) + +(cid:6)(cid:7)(cid:6) + +(cid:6)(cid:5)(cid:4) + +(cid:0)(cid:5)(cid:0) + +(cid:16)(cid:18)(cid:16)(cid:18)(cid:16) + +The (cid:2)rst number of this sequence is called the seed of the random number genera- +tor. For this type of generator, any seed in the range (cid:0) + +(cid:0) will work. + +(cid:16)(cid:18)(cid:16)(cid:21)(cid:16) + +Given the series (cid:8) + +(cid:1) , (cid:8)(cid:10)(cid:2) , (cid:8) + +(cid:0) , . . . which are numbers in the range (cid:0) + +(cid:16)(cid:18)(cid:16)(cid:21)(cid:16) + +can obtain a series of numbers in the range % + +(cid:16)(cid:18)(cid:16)(cid:21)(cid:16) + +(cid:0) by using the numbers (cid:8) + +(cid:0) , one + +(cid:18)! #" + +. Thus for the simulation of a coin that can either be head (1) or tail (0), choose + +(cid:6) , which gives the pseudo random sequence: + +(cid:16)(cid:18)(cid:16)(cid:18)(cid:16) + +This series, like the previous one, repeats itself after 30 numbers. This is the period +of the random generator, de(cid:2)ned by +. The range of the numbers is given +and +by (cid:0) +. In a general random number generator (cid:0) can be chosen by the user, but +and + +are chosen by the designer of the module to guarantee a long period. + +The SML interface of the random number module would be: + +signature RANDOM = sig + +type random ; +val random_init : random ; +val random_number : random -> int -> random ; + +end ; + +The implementation needs two values period and root that are not available to +the users of the random number generator. Here the interface places a restriction +on the SML module. + +structure Random : RANDOM = struct + +type random = (int * int) ; + +val period = 31 ; + +Revision: 6.38 + +(cid:15) +(cid:8) +(cid:8) +(cid:0) +(cid:2) +(cid:4) +(cid:8) +(cid:1) +(cid:0) +(cid:0) +(cid:8) +(cid:8) +(cid:0) +(cid:15) +(cid:8) +(cid:8) +(cid:10) +(cid:2) +, +% +(cid:15) +(cid:12) +(cid:12) +(cid:15) +(cid:12) +(cid:1) +(cid:14) +(cid:14) +(cid:8) +(cid:0) +(cid:14) +(cid:12) +(cid:0) +(cid:0) +(cid:12) +(cid:0) +(cid:2) +(cid:15) +(cid:0) +(cid:0) +(cid:6) +(cid:0) +(cid:2) +(cid:4) +(cid:1) +(cid:0) +(cid:2) +(cid:0) +(cid:2) +(cid:6) +(cid:2) +(cid:9) +(cid:6) +(cid:1) +(cid:0) +(cid:4) +(cid:6) +(cid:0) +(cid:0) +(cid:1) +(cid:2) +% +(cid:6) +% +(cid:2) +(cid:6) +(cid:6) +(cid:6) +(cid:0) +(cid:0) +(cid:0) +(cid:6) +(cid:0) +(cid:6) +(cid:0) +(cid:9) +(cid:0) +% +(cid:0) +(cid:6) +(cid:0) +(cid:6) +(cid:0) +(cid:12) +(cid:0) +(cid:12) +(cid:0) +(cid:0) +(cid:0) +(cid:8) +(cid:0) +(cid:0) +(cid:0) +(cid:0) +(cid:0) +% +(cid:0) +(cid:0) +% +% +(cid:0) +(cid:0) +(cid:0) +(cid:0) +% +% +(cid:0) +% +% +% +(cid:0) +% +% +(cid:0) +(cid:0) +% +% +% +% +(cid:0) +(cid:0) +% +(cid:0) +(cid:0) +(cid:0) +% +(cid:12) +(cid:15) +(cid:12) +(cid:15) + 8.3. Globalvariables + +265 + +val root = 11 ; + +val random_init + += (1,1) ; + +fun random_number (num,seed) range + += (seed mod range, root * seed mod period) ; + +end ; + +The caller of the random number generator receives a tuple containing the state of +the random generator and the random number that the caller required. By passing +the tuple on to the next call, random_number can calculate the next number in +the series without dif(cid:2)culties (a standard functional trick to deal with state). The +interface of the naive C version of the random number module is: + +typedef struct { +int number ; +int seed ; + +} random ; + +extern random random_init( void ) ; +extern random random_number( random state, int range ) ; + +Here is the C implementation of the random number module: + +#include "random.h" + +#define period 31 +#define root 11 + +random random_init( void ) { + +random x = {1,1} ; +return x ; + +} + +random random_number( random state, int range ) { + +random result ; +result.number = state.seed % range ; +result.seed = root * state.seed % period ; +return result ; + +} + +The caller of the function random_number has to know about the data type +random, as it must unpack this to take the number out, before passing it on to +the next call of random. Using a structure does not give rise to an elegant solution, +but with a global variable the problem can be solved satisfactorily. + +extern void random_init( void ) ; +extern int random_number( int range ) ; + +#include "random.h" + +Revision: 6.38 + + 266 + +Chapter8. Modules + +static int state ; + +#define period 31 +#define root 11 + +void random_init( void ) { + +state = 1 ; + +} + +int random_number( int range ) { +int result = state % range ; +state = root * state % period ; +return result ; + +} + +This new function random_number takes only one argument, the desired range +of the random number. The old random number is remembered in the global vari- +able named state. The function random_number thus side effects the global +variable state. The variable state is declared static: + +static int state ; + +The keyword static indicates that the variable state lives as long as the pro- +gram runs. This in contrast with local variables, which cease to exist when the +function in which they have been declared terminates. Because state is de- +clared outside the functions, state is visible to all functions in this module. In +this case, the variable state stores the last number of the sequence. Every time +random_number is called, the function calculates the random number and up- +dates state. + +The new module has a cleaner interface to the outside world, but it does have +two serious drawbacks. The (cid:2)rst drawback is that random_number is no longer a +pure function. Calling it twice with identical arguments results in different num- +bers. The second disadvantage is that the single state limits the use of the module +to a single stream of random numbers. If one program needs two independent +streams of random numbers for two different modules, the random number mod- +ule will not be able to cope with this. Thus, the present version of the random +number module is not a good building block. These problems can be alleviated by +moving the state out of the module. + +8.3.2 Moving state out of modules + +Clean C modules use a purely functional interface, as, for example, the module +on complex numbers presented in the (cid:2)rst section of this chapter. Some functions +like the random number generator shown above are naturally formulated using +state and state changes. However, they can still be designed so that they have a +clear interface. The purely functional interface of the random number module was + +Revision: 6.38 + + 8.3. Globalvariables + +267 + +inconvenient in C, while the version with state was not a good building block. A +third solution can be formulated using the following interface: + +typedef struct { + +int seed ; + +} random ; + +extern random *random_init( void ) ; +extern int + +random_number( random *state, int range ) ; +Here the function random_init generates a new state for the random number, +and the function random_number modi(cid:2)es the state pointed to by its argument +state. This is implemented as follows: + +#include "random.h" + +#define period 31 +#define root 11 + +random *random_init( void ) { + +random *state = malloc( sizeof( random ) ) ; +if( state == NULL ) { + +printf( "random_init: no space\n" ) ; +abort( ) ; + +} +state->seed = 1 ; +return state ; + +} + +int random_number( random *state, int range ) { + +int result = state->seed % range ; +state->seed = root * state->seed % period ; +return result ; + +} + +The difference between this and the functional version of random is minimal. The +functional version generated a new state, given the previous state. The impera- +tive version overwrites the old state. In comparison with the previous C version +of random, the state variable has been lifted from the module that implements +random and is now passed on to the module using the random generator. The +module random no longer contains state of its own. It has therefore a better inter- +face, even though this interface is not purely functional. In other words, the new +version of random_number has a side effect like the previous version. However, +the new version side effects one of its arguments, which is visible if we look at only +the module interface; the fact that the function random_number accepts a pointer +as one of its arguments signals that it may (and in this case will) side effect the ob- +ject pointed at by the pointer. The old version side effects a hidden state, invisible +if we look only at the interface. + +Revision: 6.38 + + 268 + +Chapter8. Modules + +8.3.3 Scoping and life time of global and local variables + +Using the technique of lifting state out of modules, global variables can almost +always be avoided. However, in some cases, global variables are the appropriate +solution. To explain this, it is important to elaborate on the lifetime and visibility +(or scoping) of variables. The variables used in the (cid:2)rst 7 chapters are all local +variables. Local variables are declared in a block. A local variable is associated +with a storage cell just before execution begins of the (cid:2)rst statement in the block. +The store is deallocated when the last statement of the block has been executed. +The block is also the scope of the variable, where it can be seen and where it can be +used. + +Variables declared static live for as long as the program executes. They are +created when the program starts and cease to exist when the program terminates. +These variables are visible to all functions in a module. When a static variable +is declared inside a function, the scope of this variable, the visibility, is restricted to +the enclosing group of statements. Consider the function counter below: + +int counter( void ) { + +static int count = 10 ; +return count++ ; + +} + +The declaration static int count = 10 creates a variable called count. The +scope of count is restricted to this function, but the lifetime of count is that of a +global variable. So count is created when the program starts; it is at that moment +initialised to 10, and then count is used by the function counter in subsequent +calls. Note that the initialisation happens only during program startup, not on +each function invocation. Thus, the function counter will return the values 10, +11, 12, 13, . . . on successive calls to counter. + +C also supports variables that are visible to any module of the program. These +variables are known as external variables. An external variable must be declared +outside a function, just like a static variable, but without the keyword static: + +int very_global_count = 10 ; + +To make an external variable visible to other modules, it should also be declared +in the header (cid:2)le of the module with the keyword extern: + +extern int very_global_count ; + +External variables can be read and written by any function in the program. Com- +munication between functions via global variables should be avoided if possible. +A good use of global variables is when data need to be broadcasted once. As an ex- +ample, one can have a boolean verbose that indicates that every function in the +whole program should print what it is doing. + +A common mistake with the use of external global variables is to have two +global variables with the same name in two separate modules of the program. The +C compiler will not complain, but the linker will silently unify these two variables +(as they share the same name space). Suppose that there are two modules and that +each module has a variable counter: +/*C module 1 with counter*/ + +Revision: 6.38 + + 8.4. AbstractDataTypes + +269 + +int counter ; + +/*C module 2 with counter*/ + +int counter ; + +These two counters are intended to be counters local to the module (they should +have been declared static, but were not). On execution, the program will have +only one variable counter, and both modules will share this variable. Needless +to say, the results will be unexpected. + +The scoping and lifetimes of the various types of variables are summarised in + +the table below: + +Class +auto +static anywhere + +Declared +Inside functions Closest scope + +Scope + +Lifetime +Function +Closest scope, but never Program +more than one module +Closest scope and +the other modules + +Program + +extern anywhere + +Functions and variables share the same name spaces and the same declaration +mechanism. That is, a function declared static is only visible to the module +where it is declared, not in any other module. Functions that are not declared +static can be used globally. Functions cannot be declared locally in a function. + +8.4 Abstract Data Types + +There is one important detail that can be improved on the modules shown earlier. +In most cases, the header (cid:2)le exports the full details of the data type on which the +module operates. As an example, the header (cid:2)le of the random number module +contains a full declaration of the type random: + +typedef struct { + +int seed ; + +} random ; + +This is undesirable as it exposes some of the internal workings of the module to its +clients, while the clients are not supposed to know it. Each time the internal details +of the type random change, the interface is changed as well, which will require all +clients of the random module to be compiled again. Worse, spelling out the details +invites programmers to use the internal details. + +It is better to omit the details of the type from the interface. C allows this by +means of an incomplete structure de(cid:2)nition. An incomplete structure de(cid:2)nition re- +quires the struct to be named, as was necessary to de(cid:2)ne a recursive type (Chap- +ter 6). This results in the following de(cid:2)nition of random: + +typedef struct random_struct random ; + +Revision: 6.38 + + 270 + +Chapter8. Modules + +the type random refers to a particular structure called +This speci(cid:2)es that +random_struct, without revealing its contents. The only operations that can be +performed on this type is to declare a pointer to it and to pass it around. The mod- +ule interface becomes: + +typedef struct random_struct random ; + +extern random *random_init( void ) ; +extern int + +random_number( random *state, int range ) ; + +Now that the internal details of the structure declaration have been removed from +the interface of the module, they must be speci(cid:2)ed in the implementation of the +module. The implementation of the module becomes: + +#include "random.h" + +#define period 31 +#define root 11 + +struct random_struct { + +int seed ; + +} ; + +random *random_init( void ) { + +random *state = malloc( sizeof( random ) ) ; +if( state == NULL ) { + +printf( "random_init: no space\n" ) ; +abort( ) ; + +} +state->seed = 1 ; +return state ; + +} + +int random_number( random *state, int range ) { + +int result = state->seed % range ; +state->seed = root * state->seed % period ; +return result ; + +} + +The declaration of the struct with the tag random_struct states that it has a +single (cid:2)eld, named seed. Note that there is no typedef; the type random was +already de(cid:2)ned in the header (cid:2)le. + +One could, for example, change the random number generator so that it uses a +better algorithm which maintains a bigger state in two integers by only changing +the implementation part of the module: + +struct random_struct { + +int state1 ; +int state2 ; + +} ; + +Revision: 6.38 + + 8.4. AbstractDataTypes + +271 + +The functions initialising the random number generator and calculating the ran- +dom numbers have to be changed accordingly. The interface to the rest of the +world remains the same. + +Exercise 8.4 Give the SML version of the hidden state random number module. + +What has been created is called an Abstract Data Type, or ADT. An ADT is a mod- +ule that de(cid:2)nes a type and a set of functions operating on this type. The structure +of the type itself is invisible to the outside world. This means that the internal +details of how the type is organised are hidden and can be changed when neces- +sary. The only public information about the type are the functions operating on +it. Note that no other module can operate on this type, as the internal structure is +unknown. + +Exercise 8.5 Sections 7.3.1 and 7.3.4, and Exercise 7.13 discussed three implemen- +tations of buffered streams: using a sliding queue, a shifting array and a +cyclic array. Design an ADT that implements a buffered stream using ei- +ther of these methods (the third implementation is the most ef(cid:2)cient). Your +ADT should have the following declarations in the header (cid:2)le: + +typedef struct buffer Buffer ; + +extern Buffer* b_create( FILE *input, int size ); +extern bool b_advance( Buffer *b, int n ) ; +Buffer *b, char *s, int n ) ; +extern void b_read( +extern int b_compare( Buffer *b, char *s, int n ) ; +extern void b_close( + +Buffer *b ) ; + +The (cid:2)rst function creates the Buffer data structure, and reads the initial +part, b_advance will advance the buffer n positions, when the end of +(cid:2)le is encountered it will return false; b_read will copy n characters to +the array s; b_compare will compare n characters with the array s; and +b_close will close the buffer and the stream. + +The ADT above de(cid:2)nes Buffer as the structure itself, requiring an explicit * in +each of the declarations. Alternatively, we could have declared: + +typedef struct buffer *AltBuffer ; + +AltBuffer b_create( FILE *input, int size ); +bool +... + +b_advance( AltBuffer b, int n ) ; + +The disadvantage of this is that it is not clear to the user of the module that the +buffer passed to b_advance is actually modi(cid:2)ed as a side effect. Explicitly declar- +ing it as a pointer clari(cid:2)es the intention of the functions. This was also the case +with the module that generates random numbers; the function that generated a +new number updated the state as a side effect. For an abstract data type that works +without side effects, the type can be declared including the pointer. + +Revision: 6.38 + + 272 + +Chapter8. Modules + +Exercise 8.6 Design an abstract data type list of strings. Your ADT should have + +the following declarations in the header (cid:2)le: + +typedef struct string_list *Slist ; + +extern Slist slist_cons( char *s, Slist tail ) ; +extern char* slist_head( Slist x ) ; +extern Slist slist_tail( Slist x ) ; +extern Slist slist_append( Slist x, Slist y ) ; +extern void slist_destroy( Slist x ) ; + +The function slist_append should not have a side effect, it should create +a new list. Decide whether to reuse the list y as the tail of the new list, or +whether to make a copy of y. + +Exercise 8.7 Section 5.7 presented a dynamic array. Implement a module which +de(cid:2)nes an abstract data type for a dynamic array storing integers. The +module should at least provide functions for creating an array, changing +the bounds, and accessing an element (with a bound check). + +Note that ADTs have explicit operations for creating and destroying data +structures, for example b_create and b_close for the buffered stream and +slist_cons, slist_append and slist_destroy for the string list module. +The explicit destruction clutters the code, but it is essential as the memory would +otherwise (cid:2)ll up with unused data structures. Many object oriented languages +have complete built-in support for data abstractions, including a garbage collector. +This is one of the reasons why many programmers prefer to use an object oriented +programming language. + +8.5 Polymorphic typing + +A module supports a number of important concepts. One of these concepts is that +of reusability. The random generator shown before returns random numbers in a +certain range. The range is an argument of the function. It would not be a good +idea to write another random generator for each range. In the same way as func- +tions are permitted to be parametrised over their argument values, it is also useful +to allow types to be parametrised. + +As an example, consider lists: a list of characters was de(cid:2)ned in Chapter 6, +a list of strings was de(cid:2)ned in Exercise 8.6. +If the user needs a list of integers, +neither of these modules can be reused. The solution to this problem in functional +languages is to use polymorphism, implemented through a type parameter. The +SML de(cid:2)nitions of a character list and a general list are: + +datatype char_list + +datatype (cid:146)a list + += Nil +| Cons of (char*char_list); + += Nil +| Cons of ((cid:146)a*(cid:146)a + +list); + +Revision: 6.38 + + 8.5. Polymorphictyping + +273 + +The (cid:146)a stands for the type parameter (‘any type will do’), and all SML functions +shown in Chapter 6 will work with this type, (cid:146)a list. The C typing mechanism +does not support parametrised types, but it does have a loophole that allows pass- +ing arguments of unspeci(cid:2)ed types. This means that polymorphism can be ef(cid:2)- +ciently supported in C, but without the type security offered by SML. In Chapter 4, +where partially applied functions were discussed, a variable of the type void * +was used to point to some arbitrary type. +In C, polymorphic lists can be con- +structed using this void pointer: + +typedef struct list_struct { + +void +struct list_struct + +*list_head ; +*list_tail ; + +} *list ; + +This type de(cid:2)nes a polymorphic list. The (cid:2)rst member of the list is a pointer to the +data, and the second element is a pointer to the next element of the list. With a lit- +tle care we can rebuild the full complement of list processing functions on the basis +of this new de(cid:2)nition. To create a cons cell, the types occurring in the C function +cons have to be changed consistently from char to void * as follows: + +list cons( void *head, list tail ) { + +list l = malloc( sizeof( struct list_struct ) ) ; +l->list_head = head ; +l->list_tail = tail ; +return l ; + +} + +With this function, we can create a list of characters as before. Because the type +of the (cid:2)rst argument of the new polymorphic cons function is void *, we must +pass a pointer to the character, rather than the character itself. To implement a +function list_hi as in Chapter 6, we might be tempted to write the following +syntactically incorrect C expression: + +cons( &(cid:146)H(cid:146), +Expressions such as &(cid:146)H(cid:146) +are illegal, as C forbids taking the address of a constant. +One might try to be clever and use the following syntactically correct code instead: + +NULL ) ) /* ILLEGAL C */ + +cons( &(cid:146)i(cid:146), + +list list_hi( void ) { + +char H = (cid:146)H(cid:146) +char i = (cid:146)i(cid:146) +list hi = cons( &H, cons( &i, NULL ) ) ; /* INCORRECT */ +return hi ; + +; +; + +} + +This version of list_hi is syntactically correct: it is legal to take the address of +a variable and use it as a pointer. However, the resulting function is incorrect, for +the result list that is created has two dangling pointers; the address of the variables +H and i point to the local variables of list_hi, which will disappear as soon as +the return statement has been executed. Thus the problem is that the lifetime of +the list exceeds that of the variables H and i. + +Revision: 6.38 + + 274 + +Chapter8. Modules + +The only correct way to create the two character list is by allocating both the +cons-cells and the characters on the heap. Ideally, the allocation of the memory is +performed by cons, so that one function captures the allocation of both the cell +and the area for the data: + +list cons( void *head, list tail ) { + +list l = malloc( sizeof( struct list_struct ) ) ; +void *copy_of_head = malloc( /*C size of the data*/ ) ; +/*C copy the data from *head to *copy_of_head*/ +l->list_head = copy_of_head ; +l->list_tail = tail ; +return l ; + +} + +There are two problems to be resolved here. Firstly how much store needs to be al- +located for the data? Secondly, how can we copy the data into the allocated store? +The (cid:2)rst problem cannot be solved by the function cons, since the size of the data +pointed to by head is unknown to cons. Therefore, the size of the data must be +passed to cons as a third argument. The second problem is resolved by using a +standard function of the C library, called memcpy. Given a source pointer (head), +a destination pointer (copy_of_head), and the size of the object involved, the fol- +lowing call will copy the data from head to copy_of_head. + +memcpy( copy_of_head, head, /*C size of the data*/ ) ; + +Therefore, the complete code for the polymorphic cons reads: + +list cons( void *head, list tail, int size ) { + +list l = malloc( sizeof( struct list_struct ) ) ; +void *copy_of_head = malloc( size ) ; +memcpy( copy_of_head, head, size ) ; +l->list_head = copy_of_head ; +l->list_tail = tail ; +return l ; + +} + +Here is an example of its use, which builds a list of lists. The C equivalent of the +SML list [ ["H","i"],["H","o"] ] would be: + +#define char_cons(c,cs) cons( c, cs, sizeof( char ) ) +#define list_cons(c,cs) cons( c, cs, sizeof( list ) ) + +list list_of_list( void ) { + +; +; +; + += (cid:146)H(cid:146) +char H += (cid:146)i(cid:146) +char i += (cid:146)o(cid:146) +char o += char_cons( &H, char_cons( &i, NULL ) ) ; +list hi +list ho += char_cons( &H, char_cons( &o, NULL ) ) ; +list hi_ho = list_cons( &hi,list_cons( &ho,NULL ) ) ; +return hi_ho ; + +} + +Revision: 6.38 + + 8.5. Polymorphictyping + +275 + +The access functions head and tail are readily generalised to polymorphic lists: + +void * head( list l ) { + +if( l == NULL ) { + +list tail( list l ) { +if( l == NULL ) { + +abort() ; + +} +return l->list_head ; + +abort() ; + +} +return l->list_tail ; + +} + +} + +Exercise 8.8 Generalise the ef(cid:2)cient iterative versions of functions length and + +nth to work with polymorphic lists. + +We are now equipped to try something more demanding. Here is the polymor- +phic version of extra_filter. The function header contains three occurrences +of void *, the (cid:2)rst and the last correspond to the extra argument handling mech- +anism, and the second occurrence corresponds to the element type of the lists that +we are manipulating. If we cannot see the difference between these types, then +the C compiler cannot see the difference either. This means that any form of type +security has vanished by the switch to polymorphic lists. + +list extra_filter( bool (*pred)( void *, void * ), + +void * arg, list x_xs, int size ) { + +if ( x_xs == NULL ) { + +return NULL ; + +} else { + +void * x = head( x_xs ) ; +list xs = tail( x_xs ) ; +if( pred( arg, x ) ) { + +return cons(x, extra_filter(pred,arg,xs,size), size); + +} else { + +return extra_filter( pred, arg, xs, size ) ; + +} + +} + +} + +Exercise 8.9 Generalise the open list version of append that makes advanced use + +of pointers (See Section 6.5.3). + +To complete this polymorphic list module, the function prototypes and the type +list may be speci(cid:2)ed in a header (cid:2)le as follows: + +#ifndef LIST_H +#define LIST_H + +typedef struct list_struct *list ; + +Revision: 6.38 + + 276 + +Chapter8. Modules + +extern list cons( void *head, list tail, int size ) ; + +extern int + +length( list x_xs ) ; + +extern void *head( list l ) ; +extern void *nth( list x_xs, int n ) ; +extern list tail( list l ) ; +extern list append( list xs, list ys, int size ) ; +extern list extra_filter( bool (*pred)( void *, void * ), + +void * arg, list x_xs, +int size ) ; + +#endif /* LIST_H */ + +The type list is a pointer to an incomplete structure, since the structure +list_struct is not de(cid:2)ned in this header (cid:2)le. The type that is supplied to cons +is void *, which is also the type returned by the functions head and nth. As +explained at the end of Chapter 4, the C compiler is not fussy about the use of +void *. The compiler will neither require a list to contain elements of the same +type, nor verify that the type of something that is put in the list matches the type +that is coming out of the list. This is in contrast with the security offered by a +strongly typed polymorphic language. In C, we can add type security at runtime, +but we have to pay the costs of a longer run time. Alternatively, we can implement +a set of functions for each type which does offer type safety, but which is undesir- +able from a software engineering point of view. + +8.6 Summary + +The following C constructs were introduced: + +Header and implementation (cid:2)les In C, the interface of a module is de(cid:2)ned in the + +header (.h) (cid:2)le, and the implementation in the source (.c) (cid:2)le. + +Preprocessor The C preprocessor processes the text of a C program before the +actual compilation. The three most important directives are #define, +#include and #ifndef. The #define directive will cause a macro name +to be (literally) replaced with a sequence of characters. The #include direc- +tive literally includes a (cid:2)le (typically a header (cid:2)le of a module) at that place +in the source. The #ifndef directive leaves text out if a macro has been de- +(cid:2)ned: + +#ifndef (cid:0) + +#include "filename" +#define + +( (cid:8) , (cid:2) ...) (cid:1) + +#endif /* (cid:0) */ + +Revision: 6.38 + +(cid:12) + 8.6. Summary + +277 + +are identi(cid:2)ers, (cid:8) and (cid:2) are parameters of the macro being de- +Here, (cid:0) and +is the replacement text for the macro. If there are no parameters, +(cid:2)ned, and (cid:1) +the parentheses should be omitted. The replacement text and parameters are +usually enclosed in parentheses otherwise macro substitution would end in +chaos. + +Global variables Global variables are variables that are declared outside the +scope of a function. Every function can read or write them. They may even +be visible outside modules, if another module, either deliberately or acciden- +tally, uses a variable with the same name. + +Static functions and variables Static variables have a life time as long as global +variables, but they are not visible outside a module or function. Static func- +tions are functions that are private to a module. Variables and functions are +declared static by prepending their declaration with the keyword static. + +Separate compilation The module system of C facilitates separate compilation. +When the interface of a module changes, all modules using this changed in- +terface need recompilation. The programming environment will almost al- +ways supply the necessary tools. The UNIX programming environment pro- +vides the program make for this purpose. + +Incomplete structure de(cid:2)nition None of the details of a structure need to be spec- + +i(cid:2)ed in a header (cid:2)le. The header can just specify a type: + +typedef struct (cid:3) + +(cid:1) ; + +Provided that the implementation of the module speci(cid:2)es the structure com- +pletely: + +struct (cid:3) { + +... + +} ; + +The clients importing the header can only pass values of type (cid:1) around, only +the module where the implementation is de(cid:2)ned knows the details of (cid:1) . + +Modules are fundamental for good software engineering: + +(cid:1) Modularisation is essential to structure large programs. In C, modules are +supported by the C preprocessor and are not as advanced as modules found +in other languages. In particular, modules can be imported twice (leading to +compilation errors), and one cannot selectively import parts of a module. + +(cid:1) Only those items that are really needed by the outside world should be ex- +ported by de(cid:2)ning such items in an interface. Types and internal functions +should be con(cid:2)ned to the implementation of the module. + +(cid:1) An Abstract Data Type, ADT, speci(cid:2)es a type and a set of operations. The +internal workings of an ADT are shielded off by the module. This localises +design and maintenance effort, and gives modules that are easily reused. + +Revision: 6.38 + +(cid:12) + 278 + +Chapter8. Modules + +(cid:1) A variable should be declared so that the scope is as small as possible, and +the lifetime is as short as possible. Avoid global variables, instead store the +state in a structure, and pass a pointer explicitly to the functions operating +on it. + +(cid:1) Modules using polymorphic data types can be built in C using the void +pointer. They are only type safe if the programmer invests in runtime checks. +Ef(cid:2)cient polymorphic data types in C can only be built in a type unsafe way. + +8.7 Further exercises + +Exercise 8.10 Functions with a small domain are often implemented using a memo +table. For each value in the domain, one would keep the corresponding +function value. +Instead of computing the value, it is merely looked up. +The factorial function is a good example of a function with a small domain. +Here is a table of some of its values: + +1 +2 +3 +4 +5 +6 +7 +8 +9 +10 +11 +12 +13 +14 + +1 +2 +6 +24 +120 +720 +5,040 +40,320 +362,880 +3,628,800 +39,916,800 +479,001,600 +6,227,020,800 +87,178,291,200 + +The function values grow so quickly that, with 32-bit arithmetic, over(cid:3)ow +occurs for (cid:0) +(cid:1) . Thus a table of 12 values is suf(cid:2)cient to maintain the entire +domain and range of the factorial function for 32-bit arithmetic. +Write a C function that uses an array as a memo table. Your function should +compute the appropriate values just once, and it should not compute more +values than strictly necessary. When the argument is beyond the domain, +your function should abort. + +Exercise 8.11 Exercise 8.7 required the implementation of a dynamic array of in- +tegers. De(cid:2)ne a module that implements a polymorphic dynamic array. +Upon creation of the array, the size of the data elements is passed, subse- +quent functions (for indexing and bound changes) do not need extra pa- +rameters. + +Revision: 6.38 + +(cid:15) +(cid:15) +(cid:1) +(cid:2) + 8.7. Furtherexercises + +279 + +Exercise 8.12 Write a higher order polymorphic version of the quicksort function +from Chapter 7 that takes a comparison function as an argument so that it +can sort an array of any data type. + +Exercise 8.13 A snoc list is an alternative representation of a list, which stores the +head and the tail of a list in reverse order. Here is the SML de(cid:2)nition of the +snoc list: + +datatype (cid:146)a snoc_list = Snoc of ((cid:146)a snoc_list * (cid:146)a) +| Nil ; + +Three numbers 1, 2 and 3 could be gathered in a snoc list as follows: + +Snoc(Snoc(Snoc(Nil,1),2),3) ; + +An equivalent ordinary list representation would be: + +Cons(1,Cons(2,Cons(3,Nil))) ; + +This uses the following de(cid:2)nition of a polymorphic list: + +datatype (cid:146)a list = Nil + +| Cons of ((cid:146)a * (cid:146)a list) ; + +Note that in both representations the order of the elements is always 1, 2, 3. +Here is the C data structure that we will be using to represent snoc lists: + +typedef struct snoc_struct { + +void +* snoc_tail ; +struct snoc_struct * snoc_head ; + +} * snoc_list ; + +(a) De(cid:2)ne the C functions snoc, head and tail similar to those at the +beginning of this chapter 6, but associated with the type snoc_list. +(b) Create a higher order C function sprint with the following proto- + +type: + +void sprint(void (*print) ( void * ), snoc_list l ) ; + +The purpose of this function is to print all elements of the snoc list +and in the correct order. Use a comma to separate the elements when +printed. + +(c) Write a main function to test your snoc list type and the associated + +functions. + +Exercise 8.14 An + +-ary tree is a generalisation of a binary tree, which has + +branches at each interior node rather than just two. The following SML data +-ary tree with integer values at the leafs. Here we +structure represents an +have chosen to use the snoc list from the previous exercise. +datatype ntree = Br of (ntree snoc_list) + +| Lf of int ; + +Revision: 6.38 + +(cid:15) +(cid:15) +(cid:15) + 280 + +Chapter8. Modules + +Here is a sample ntree: + +1 + +2 + +3 + +4 + +In an SML program, the sample ntree could be created as follows: + +val sample += let + +val l234 = Snoc( Snoc( Snoc( Nil, Lf 2 ), + +Lf 3 + +), + +Lf 4 + +) + +in + +Br (Snoc( Snoc( Nil, Lf 1 ), + +Br ( l234 ) + +) + +) + +end ; + +(a) Give an equivalent type de(cid:2)nition of the SML ntree above in C. Use + +the snoc_list as de(cid:2)ned in the previous exercise. + +(b) Write a C function nlf to create a leaf from a given integer key value. +Also write a C function nbr to construct a branch from a given snoc +list of n-ary trees. + +(c) Write a function nprint with this prototype: + +void nprint( ntree t ) ; + +Your function should print an ntree as follows: + +1. For each leaf print the key value kept in the leaf. +2. Print all elements of a snoc list of branches enclosed in parenthe- + +ses. Use the function sprint from the previous exercise. + +The sample ntree above should thus be printed as: (1,(2,3,4)). +(d) Write a C main program to create the sample ntree above and print + +it using nprint. + +Exercise 8.15 In Exercises 8.13 and 8.14 we have created a data structure, and sets +of functions operating on the data structure. Package each data structure +with its associated functions into a separate C module. + +Revision: 6.38 + + 8.7. Furtherexercises + +281 + +(a) Create a C header (cid:2)le and a C implementation for the snoc list data + +type and the functions snoc, head, tail and sprint. + +(b) Create a C header (cid:2)le and a C implementation for the ntree data type + +and the functions nlf, nbr and nprint. + +(c) Write a program to test that your modules are usable. + +Revision: 6.38 + + 282 + +Chapter8. Modules + +Revision: 6.38 + + c(cid:0) + +1995,1996 Pieter Hartel & Henk Muller, all rights reserved. + +Chapter 9 + +Three case studies in graphics + +In this chapter we will make three case studies to put in practice the principles +and techniques introduced before. The (cid:2)rst case study is a small program to draw +a fractal using X-windows. The second study is a device independent graphics +driver, using X-windows, PostScript, and possibly some other graphics output de- +vices. The third case study is an interpreter for an elementary graphics descrip- +tion language, called gp. The gp interpreter uses the device independent graphics +driver of the second case study. + +The three case studies are increasingly more dif(cid:2)cult, and the amount of detail +left to the reader also increases. The (cid:2)rst case study spells out the data structures +and algorithms to be used. The second case study gives the data structures and +some code. The third case study only suggests the data structures that might be +used. The reader is encouraged to work out these case studies. + +All programs use X-windows to render the graphics. Being able to use the X- +windows library is at the same time a useful skill and a good test of one’s program- +ming abilities. We choose the X-windows system because it is widely available; it +runs on PC’s, workstations and the Macintosh; and it is public domain software. +The disadvantage of choosing the X windows system is that it is a complex system, +especially for the beginning programmer. For this reason, we use only an essen- +tial subset of X. The interested reader is referred to the X-windows programming +manuals for complete details [17]. + +9.1 First case study: drawing a fractal + +The Mandelbrot set is a fractal, a shape that is irregular, no matter how far it is mag- +ni(cid:2)ed. It is also a pretty picture. We will write a program to render such a picture +on the screen. To perform the actual drawing on the screen, we use the X-windows +toolkit. + +We divide the problem into two parts. First we will de(cid:2)ne the Mandelbrot set +and de(cid:2)ne a module that computes whether a point is part of the set or not. Then +a module is de(cid:2)ned that displays the points on the screen. These two modules +constitute a relatively complicated program which will be developed by re(cid:2)ning +an initial, inef(cid:2)cient version to a (cid:2)nal ef(cid:2)cient version. + +283 + + 284 + +Chapter9. Threecasestudies ingraphics + +9.1.1 De(cid:2)ning the Mandelbrot set + +The Mandelbrot set is de(cid:2)ned as follows. Given a point (cid:3) +the recurrence relation below de(cid:2)nes a series + +of complex numbers + +in the complex plane, + +(cid:6)(cid:5) + +(cid:16)(cid:21)(cid:16)(cid:18)(cid:16) : + +For some choices of the point (cid:3) , the series +(cid:1) , the series is: +amples. If (cid:3) + +diverges. Take the following two ex- + +if (cid:0) + +For another choice, (cid:3) + +(cid:0)(cid:7)(cid:0) + +(cid:0) , the series is: + +(cid:2)(cid:5)(cid:9)(cid:3)(cid:2)(cid:5)(cid:4) + +(cid:16)(cid:18)(cid:16)(cid:21)(cid:16) + +An example value of (cid:3) for which the series does not diverge is (cid:3) + +&% + +(cid:0) : + +(cid:0)(cid:7)(cid:0) + +(cid:16)(cid:18)(cid:16)(cid:18)(cid:16) + +(cid:3)(cid:2) + +(cid:3)(cid:2) + +(cid:3)(cid:2) + +(cid:9)(cid:5)(cid:9) + +(cid:16)(cid:18)(cid:16)(cid:18)(cid:16) + ++(cid:29) + +This series converges to % +that +which the series +pretty picture results. + +(cid:0) , the series + +(cid:9) . In general, if for a given (cid:3) , there is a (cid:0) such +diverges. The Mandelbrot set is de(cid:2)ned as all points (cid:3) for +converges. If the set of points is plotted in the complex plane, a + +The program that we are going to develop will calculate an approximation to +the Mandelbrot set. To decide whether a point belongs to the set, it would be nec- +essary to compute all points of the series +, which is an in(cid:2)nite task. We are going +to approximate this by calculating only a (cid:2)xed length pre(cid:2)x of each series. If this +pre(cid:2)x does not diverge, then we assume that the in(cid:2)nite series does not diverge. +The approximation can be improved by increasing the number of steps, but at the +expense of extra run time. + +The solution to the Mandelbrot problem is (cid:2)rst given in SML. We will also need +the complex arithmetic module from Chapter 8. The function that decides whether +a point belongs to the Mandelbrot set is: + +(* in_Mandelbrot : Complex.complex -> bool *) +fun in_Mandelbrot c + += let + +open Complex +val MAXSTEPS = 31 +fun step i z += let + +val z(cid:146) = complex_sub (complex_multiply z z) c + +in + +if complex_distance z > 1.0 + +then false + +Revision: 1.25 + +(cid:5) +(cid:5) +(cid:1) +(cid:14) +(cid:2) +(cid:14) +(cid:5) +(cid:1) +(cid:14) +(cid:3) +(cid:0) +(cid:0) +(cid:5) +(cid:1) +(cid:0) +% +(cid:5) +(cid:1) +(cid:1) +(cid:2) +(cid:0) +(cid:5) +(cid:0) +(cid:1) +(cid:0) +(cid:3) +(cid:14) +, +% +(cid:5) +(cid:0) +(cid:5) +(cid:0) +% +(cid:14) +(cid:0) +(cid:1) +(cid:14) +(cid:0) +(cid:6) +(cid:14) +(cid:0) +(cid:1) +% +(cid:14) +(cid:0) +(cid:14) +(cid:0) +(cid:5) +(cid:0) +% +(cid:14) +(cid:0) +(cid:0) +(cid:2) +(cid:0) +(cid:14) +(cid:0) +(cid:0) +(cid:14) +(cid:0) +(cid:0) +(cid:2) +(cid:2) +(cid:0) +(cid:14) +(cid:0) +(cid:2) +(cid:2) +(cid:6) +(cid:0) +(cid:14) +(cid:0) +(cid:16) +(cid:5) +(cid:0) +% +(cid:14) +(cid:0) +% +(cid:16) +(cid:0) +(cid:14) +(cid:0) +% +(cid:16) +% +(cid:14) +(cid:0) +% +(cid:16) +% +(cid:0) +(cid:2) +(cid:14) +(cid:0) +% +(cid:16) +% +(cid:0) +(cid:1) +(cid:2) +(cid:2) +(cid:14) +(cid:16) +(cid:9) +(cid:0) +(cid:0) +% +(cid:16) +(cid:2) +(cid:29) +(cid:5) +(cid:1) +, +(cid:5) +(cid:5) +(cid:5) + 9.1. Firstcasestudy: drawingafractal + +285 + +else if i > MAXSTEPS + +then true +else step (i+1) z(cid:146) + +end + +in + +step 0 (0.0,0.0) + +end ; + +The corresponding C implementation needs to import the complex number mod- +ule, and the boolean module (both from Chapter 8): + +#include +#include "mandelbrot.h" +#include "complex.h" +#include "bool.h" + +#define MAXSTEPS 31 + +bool in_Mandelbrot( complex x ) { + +complex z = {0,0} ; +int i = 0 ; + +while( true ) { + +if( complex_distance( z ) > 1.0 ) { + +return false ; + +} else if( i > MAXSTEPS ) { + +return true ; + +} +z = complex_multiply( z, z ) ; +z = complex_sub( z, x ) ; +i++ ; + +} + +} + +The interface of this module to the external world is: + +#ifndef MANDELBROT_H +#define MANDELBROT_H + +#include "bool.h" +#include "complex.h" +extern bool in_Mandelbrot( complex x ) ; + +#endif + +The function in_Mandelbrot is exported, but MAXSTEPS is not exported. This +hides the details of how accurate the approximation is, so that the approximation +can be changed without having to change functions that use in_Mandelbrot. + +Revision: 1.25 + + 286 + +Chapter9. Threecasestudies ingraphics + +9.1.2 Drawing the fractal on the screen + +Before we show which functions the X-windows library provides to draw some- +thing on the screen, we give a short overview of the X-windows package. The +(cid:2)gure below shows a possible environment where X-windows can be used. + +Network + +Displays + +Windows + +Pixels + +This particular con(cid:2)guration shows three computers, two of which have a dis- +play. The computers are connected via a network. An X application can run on any +computer (whether it has a screen or not) and can use any number of displays on +the network. As an example, a multi user game could run on the computer in the +middle and use the two displays connected to systems on the left and right. Sim- +ple applications, like an editor, will often use only one display and will execute on +the machine connected to that display. + +Within a display, an X-application distinguishes one or more windows that it +controls. Most applications will use a single window, but an application can con- +trol an arbitrary number of windows. Within a window, the application program +can do whatever it wants; the X-server will not allow an application to write out- +side its window to avoid destroying other windows, nor will it allow writing in +parts of a window that are obscured by other windows. + +Each window of an X application is composed of a grid of dots, or pixels. Each +dot has a speci(cid:2)c colour. On a monochrome display, a dot can be ‘black’ or ‘white’, +but most modern computers have a colour screen, allowing a pixel to have any of +a large range of colours. Each pixel on the grid is addressed with a coordinate. +The coordinate system is slightly unusual: the origin is in the top left hand corner, +the X coordinates run from left to right, and the Y coordinates run top-down. So the +top left hand pixel of a window is the pixel with coordinates +, the next one +, and so on. The X library provides functions, for example, to +down is pixel +(cid:2)ll a rectangular area of dots with a colour, or to render some characters. + +Given that an X application may use multiple displays and windows, the spe- +ci(cid:2)c window and display to be used must be speci(cid:2)ed when performing some +graphics operation. This information is not stored implicitly in the library, but +must be explicitly passed by the program. This might be confusing at (cid:2)rst because +many applications use only one display and one window, but it makes the library +more general. The X designers could have stored a (cid:147)Current display(cid:148) and (cid:147)Cur- +rent window(cid:148) in global variables to shorten the argument list, but have (in our +opinion rightly) chosen to avoid the global state. + +Revision: 1.25 + +(cid:1) +% +(cid:14) +% +(cid:8) +(cid:1) +% +(cid:14) +(cid:0) +(cid:8) + 9.1. Firstcasestudy:drawingafractal + +287 + +In addition to specifying which display and window to use, all functions us- +ing graphics capabilities must indicate how the graphics operations are to be per- +formed. This gives, for example, the colour and font to use when drawing a string +of text. This is passed via an object known as a graphics context. Again, the de- +signers of the X-windows system have chosen to pass this explicitly, as opposed to +maintaining a current font or current colour in a global variable. A graphic con- +text can be dynamically created and destroyed, and there are functions available +to modify certain (cid:2)elds in a context. + +Now that we know the morphology of a window in the X-windows system, it +has to be decided how to draw the Mandelbrot set on the screen. The module in +the previous section de(cid:2)nes, for any point in the complex plane, whether the point +is part of the (approximated) Mandelbrot set. In a window, we can only display +part of the complex plane, and we can only show it with a (cid:2)nite resolution, given +by the number of pixels. The (cid:2)gure below shows the Mandelbrot set drawn with a +high resolution (left) and a window (right) from (cid:0) +(cid:0) , with + +(cid:0) to (cid:0) + +(cid:6)(cid:5)(cid:9) + +(cid:6)(cid:3)(cid:9) + +(cid:6)(cid:3)(cid:9) + +(cid:6)(cid:3)(cid:9) + +% pixels on this window. + +/(cid:14) + +(cid:1)(cid:0) + +(cid:3)(cid:2) + +To display the Mandelbrot set, a mapping must be devised from the +inte- +ger coordinates of the window to the complex plane. Assuming that the window +measures (cid:4) +(cid:0) , and +showing an area of the complex plane with size (cid:7) +(cid:0) , then the complex number + +pixels, with the middle of the window on position (cid:8) + +(cid:6)(cid:5) + +(cid:0) is related to + +and + +/(cid:14) + +as follows: + +(cid:3)(cid:2) + +(cid:7)(cid:5) + +(cid:8)(cid:5)(cid:2) + +The C implementation of this speci(cid:2)cation is shown below. The identi(cid:2)ers have +been given slightly more descriptive names (WIDTH (cid:0) + +, HEIGHT (cid:0) + +, width (cid:0) + +(cid:8)(cid:4) + +, and height (cid:0) +static + +(cid:14) ): + +Revision: 1.25 + +(cid:0) +(cid:16) +(cid:0) +(cid:0) +(cid:16) +(cid:16) +(cid:2) +(cid:0) +(cid:16) +(cid:6) +% +(cid:5) +(cid:6) +(cid:1) +(cid:8) +(cid:5) +(cid:2) +(cid:2) +(cid:5) +(cid:14) +(cid:3) +(cid:0) +(cid:0) +(cid:2) +(cid:12) +(cid:0) +(cid:2) +(cid:0) +(cid:14) +(cid:4) +(cid:14) +(cid:0) +(cid:2) +(cid:4) +(cid:0) +(cid:14) +(cid:12) +(cid:14) +(cid:8) +(cid:14) +(cid:2) +(cid:14) +(cid:7) +(cid:14) +(cid:14) +(cid:0) +(cid:2) +(cid:6) +(cid:0) +(cid:0) +(cid:7) +(cid:0) +(cid:4) +(cid:0) +(cid:7) +(cid:6) +(cid:12) +(cid:0) +(cid:2) +(cid:2) +(cid:14) +(cid:2) +(cid:5) +(cid:0) +(cid:14) +(cid:6) +(cid:5) +(cid:7) + 288 + +Chapter9. Threecasestudies ingraphics + +complex window_to_complex( int X, int Y, + +int WIDTH, int HEIGHT, +double x, double y, +double width, double height ) { + +complex c ; +c.re = x + width * X / WIDTH - width/2 ; +c.im = y + height * Y / HEIGHT - height/2 ; +return c ; + +} + +The expression width * X / WIDTH that is used to scale X deserves attention +as the expression is less innocent than it looks at (cid:2)rst sight. The variables X and +WIDTH are integers, while width is a (cid:3)oating point number. Suppose the compiler +would have interpreted the expression as follows: + +width * ( X / WIDTH ) + +In this case the division operator would be interpreted as an integer division. Be- +cause X < WIDTH, this division would always return 0, which is not the desired +result. Because the * and / operators have equal precedence and are left associa- +tive, the parentheses are inserted properly. The program will (cid:2)rst multiply width +with X, and then perform a (cid:3)oating point division with WIDTH (as the result of +width * X is a (cid:3)oating point number). It would be better to insert an explicit +type coercion to ensure that the / is a (cid:3)oating point division, for example: + +width * X / (double) WIDTH + +Using the function window_to_complex, a point on the screen can be trans- +lated to a point on the complex plane, and with the function in_Mandelbrot, +we can test whether this point belongs to the Mandelbrot set. All that is needed +now is the function that draws a pixel on the window. For this purpose, we use +the X-windows function XFillRectangle, which (cid:2)lls a rectangular area on the +screen. Seven arguments must be passed to this function: on which display and +which window is the rectangle to appear, which graphics context is to be used +to draw the rectangle, and (cid:2)nally the description of the rectangle. The function +XFillRectangle has the following prototype: + +void XFillRectangle( Display *d, Window w, GC gc, + +int x, int y, +int width, int height ) ; + +The rectangle is uniquely determined by the coordinates of its upper left cor- +ner (x and y) and its width and height, all measured in pixels. The function +XFillRectangle can be embedded in a function that draws one pixel on a win- +dow. This effectively packages the required functionality and provides it with a +nicer interface. + +static +void draw_pixel( Display *theDisplay, Window theWindow, + +long colour, +int x, int y ) { + +GC gc = XCreateGC( theDisplay, theWindow, 0, NULL ) ; + +Revision: 1.25 + + 9.1. Firstcasestudy: drawingafractal + +289 + +XSetForeground( theDisplay, +XFillRectangle( theDisplay, theWindow, gc, x, y, 1, 1); +/* Inefficient */ +XFreeGC( theDisplay, gc ) ; + +gc, colour ) ; + +} + +The function draw_pixel has (cid:2)ve arguments: +the display, the window, the +colour that we wish to use, and the x- and y-coordinates of the pixel to be drawn. +Before we can use a graphics context, it must be created. This is taken care of by +the function XCreateGC. The colour of the graphics context is modi(cid:2)ed by calling +XSetForeground. After we have (cid:2)nished with the graphics context, it must be +deallocated, which is accomplished by the function XFreeGC. This is an inef(cid:2)cient +process; we will come back to this later. + +The type of colour is long, which is an abbreviation for a long integer. The +type of theDisplay is a pointer, while theWindow, and gc are not pointers +(the types are respectively Display *, Window and GC). To make it more con- +fusing, the type GC is actually a pointer type, which explains why the function +XSetForeground can modify the contents of the graphics context passed to it. It +is an unfortunate fact of life that, when using real world libraries, some functions +require explicit pointer types, while other types are pointers implicitly. + +Using draw_pixel it is now possible to implement a function that draws the +Mandelbrot set. The function draw_Mandelbrot below iterates over all pixels of +the window and draws each pixel accordingly: + +static +void draw_Mandelbrot( Display *theDisplay, Window theWindow, + +long black, long white, +int WIDTH, int HEIGHT, +double x, double y, +double width, double height) { + +int X, Y ; +complex c ; +for( X=0 ; X +#include +#include +#include "complex.h" +#include "mandelbrot.h" + +Furthermore, a Makefile is needed, and during the linking stage of the program, +we need to tell the compiler to use the X11, X-toolkit, and mathematical libraries: + +OBJECTS= main.o complex.o mandelbrot.o + +mandelbrot: $(OBJECTS) + +$(CC) -o mandelbrot $(OBJECTS) -lXt -lX11 -lm + +depend: + +makedepend $(CFLAGS) main.c complex.c mandelbrot.c + +Revision: 1.25 + +(cid:0) +(cid:16) +(cid:0) +(cid:0) +(cid:16) +(cid:16) +(cid:2) +(cid:0) +(cid:16) + 292 + +Chapter9. Threecasestudies ingraphics + +The exact calling syntax for the compiler and linker is machine dependent. +On some machines the user will have to add include and or library path op- +tions to the compiler. +the compiler might require an option +-I/usr/local/X11/include, and the (cid:2)nal linking stage might need the op- +tion -L/usr/lib/X11. The local documentation may give more details on how +X11 is installed on the machine. + +For example, + +Compiling and executing this program will draw a small Mandelbrot graphic. +Stopping the program in its present form is a bit of a problem, as the program will +wait inde(cid:2)nitely. Interrupting the program or destroying the window are the only +solutions; we will resolve this problem later. + +Depending on the speed of your computer system, you can choose to increase +the size of the window (WIDTH and HEIGHT) or the accuracy of the approximation +to the Mandelbrot set (by increasing MAXSTEPS). + +Exercise 9.1 What would happen if the C-preprocessor directives that de(cid:2)ne + +WIDTH and HEIGHT were de(cid:2)ned before the (cid:2)rst function of this module? + +9.1.3 Shortening the argument lists + +the + +three functions window_to_complex, draw_pixel, + +and +Each of +draw_Mandelbrot has a large number of arguments. This is undesirable, as it +does not look pretty, it is too much work to type, and it sometimes obscures the +purpose of a function. Here are the prototypes of the relevant functions gathered +together: + +complex window_to_complex( int X, int Y, + +int WIDTH, int HEIGHT, +double x, double y, +double width, double height ) ; + +void draw_pixel( Display *theDisplay, Window theWindow, + +long colour, +int x, int y ) ; + +void draw_Mandelbrot( Display *theDisplay, Window theWindow, + +long black, long white, +int WIDTH, int HEIGHT, +double x, double y, +double width, double height) ; + +Some of these arguments are unnecessary, since they are constant. As an example, +the variable theDisplay is a constant: it is set once (in the main program) and +used afterwards in many functions. As this application uses only one display, we +can choose to make theDisplay a static variable by declaring it before the (cid:2)rst +function of the module as follows: + +static Display *theDisplay ; + +Revision: 1.25 + + 9.1. Firstcasestudy:drawingafractal + +293 + +Similarly, theWindow, black, and white can be de(cid:2)ned as global constants +(thereby restricting our application to using at most one window). The variables +WIDTH and HEIGHT are proper constants, de(cid:2)ned before main. If we move these +de(cid:2)nitions forward, we can use them in window_to_complex. This process re- +sults in a list of global variables and constants that need to be declared before the +functions: + +static Display *theDisplay ; +static Window +static long + +theWindow ; +black, white ; + +#define WIDTH +100 +#define HEIGHT 100 + +The function window_to_complex does not need the HEIGHT and WIDTH argu- +ments anymore. Its de(cid:2)nition can be simpli(cid:2)ed to the following: + +static +complex window_to_complex( int X, int Y, + +double x, double y, +double width, double height ) { + +complex c ; +c.re = x + width * X / WIDTH - width/2 ; +c.im = y + height * Y / HEIGHT - height/2 ; +return c ; + +} + +The other functions, draw_pixel and draw_Mandelbrot, can be simpli(cid:2)ed in +a similar fashion. Before showing the new code we will remove an inef(cid:2)ciency in +the original code. Each time that the function draw_pixel is called, a graphics +context is created and destroyed. It is more ef(cid:2)cient to create this graphics context +only once in the function draw_Mandelbrot and to reuse it in draw_pixel a +number of times. The graphics context must be destroyed in draw_Mandelbrot +just prior to leaving the function. This optimisation results in the following code: + +static +void draw_pixel( GC gc, long colour, int x, int y ) { + +XSetForeground( theDisplay, +XFillRectangle( theDisplay, theWindow, gc, x, y, 1, 1); + +gc, colour ) ; + +} + +static +void draw_Mandelbrot( double x, double y, + +double width, double height) { + +int X, Y ; +GC gc = XCreateGC( theDisplay, theWindow, 0, NULL ) ; +for( X=0 ; Xx, r->y, r->width, r->height ) ; + +} + +When an expose event comes in, the entire Mandelbrot graphic is drawn. It is not +always necessary to draw the whole Mandelbrot graphic, because sometimes only +parts of the window need to be redrawn. Inspecting the e argument would allow +the program to (cid:2)nd out exactly which parts need to be redrawn, but that is beyond +the scope of this example. + +Revision: 1.25 + + 296 + +Chapter9. Threecasestudies ingraphics + +Now that this event is being handled properly, it is no longer necessary to draw +the Mandelbrot graphic in the main program, for as soon as the window has been +created, an Expose event is posted automatically by the library. This will cause +the Mandelbrot graphic to be drawn. Thus the call to draw_Mandelbrot will be +removed from the main program: + +int main( int argc , char *argv[] ) { + +XtAppContext context ; +int +rectangle +Widget widget = XtVaAppInitialize( &context, "XMandel", + +theScreen ; +r ; + +NULL, 0, &argc, argv, NULL, NULL ) ; + +XtVaSetValues( widget, XtNheight, HEIGHT, + +XtNwidth, WIDTH, NULL ) ; + +XtRealizeWidget( widget ) ; +theDisplay = XtDisplay( widget ) ; +theWindow = XtWindow( widget ) ; +theScreen = DefaultScreen( theDisplay ) ; +white +black +printf("Enter originx, y, width and height: " ) ; +if( scanf( "%lf%lf%lf%lf", &r.x, &r.y, &r.width, + += WhitePixel( theDisplay, theScreen ) ; += BlackPixel( theDisplay, theScreen ) ; + +printf("Sorry, cannot read these numbers\n" ) ; + +&r.height ) != 4 ) { + +} else { + +XtAddEventHandler( widget, ExposureMask, false, + +handle_expose, &r ) ; + +XtAppMainLoop( context ) ; + +} +return 0 ; + +} + +When XtAddEventHandler is called, the function handle_expose is stored in +a data structure linked to the widget. The details of the store are well hidden, +but one can envisage that the Widget structure maintains a list of functions that +handle events, as follows: + +Revision: 1.25 + + 9.1. Firstcasestudy: drawingafractal + +297 + +Widget + +x,y: + +13,15 + +EventHandler List + +Event Handler: + +Event: + +ExposureMask + +func: + +HandleExpose + +extra arguments: + +x: + +y: + +width: + +height: + +The function XtAppMainLoop can (cid:2)nd out which functions are to be noti(cid:2)ed for +which events. It does so via the variable context, which maintains a pointer to +the top level widget. The function XtAppMainLoop then calls these functions +with the appropriate extra arguments when necessary (the precise structure is +more complicated than sketched here). + +Another event that we might be interested in is when the user presses a button +on the mouse. We can use this action to let the user indicate that the application +should stop. Reacting to this button requires adding another event handler to the +program: + +XtAddEventHandler( widget, ButtonPressMask, false, + +handle_button, NULL ) ; + +The function handle_button must be de(cid:2)ned as: + +void handle_button( Widget w, XtPointer data, + +XEvent *e, Boolean *cont ) { + +exit( 0 ) ; + +} + +The call to exit gracefully stops the program. + +This concludes the presentation of our (cid:2)rst case study. + +It is still a relatively +small C program but it performs an interesting computation and renders its results +graphically using a windows-library. The program combines a number of good +software engineering techniques to create a structure of reusable modules. The +program can be extended to enhance its functionality, for example, to use colour +instead of black and white rendering, or to zoom in on certain areas of the complex +plane. + +Exercise 9.2 Modify the Mandelbrot program to draw using different colours. Use +the number of steps made to decide which colour to use. The Mandelbrot + +Revision: 1.25 + + 298 + +Chapter9. Threecasestudies ingraphics + +set itself stays black, the area outside the Mandelbrot set will be coloured. +Here are a few functions to use from the X-windows library: +DefaultColormap( d, s ) returns the colour map of screen s on dis- + +play d. + +XAllocColorCells( d, c, 1, NULL, 0, col, n ) When given a +display d, a colour map c, and an array col of n longs, this function +will allocate n colours and store them in the array col. The function +XAllocColorCells only allocates colours, it does not (cid:2)ll them with +speci(cid:2)c colours. This means that each of the longs in the array is now +initialised with a value which refers to an as yet unde(cid:2)ned colour. +XStoreColor( d, c, &colour ) This function (cid:2)lls one particular +colour. The variable colour is a structure of type XColor which has +the following members: +long pixel This should be the reference to the colour that you want + +to set. + +unsigned short red, green, blue These are the values for the +red, green, and blue components: 0 means no contribution of that +colour and, 65535 means maximum; 0,0,0 represents black; 65535, +65535, 65535 represents white. + +int flags This (cid:2)eld informs which values to set in the colour table, + +The value DoRed | DoGreen | DoBlue sets all colours. + +Here is an example of a function that manipulates the colour map: + +#define NCOLOURS 1 +static unsigned long cells[NCOLOURS] ; + +void setcolours( Display *d, int screen ) { + +XColor colour ; +Colormap c = DefaultColormap( d, screen ) ; +XAllocColorCells( d, c, 1, NULL, 0, cells, NCOLOURS ) ; +colour.flags = DoRed | DoGreen | DoBlue ; += 65535 ; +colour.red +colour.green = 55255 ; +colour.blue = 0 +; +colour.pixel = cells[0] ; +XStoreColor( d, c, &colour ) ; + +} + +The function setcolours creates a single colour, gold in this case. When- +ever XSetForeground is called with cells[0] as the colour, the pixels +will be rendered gold. + +Revision: 1.25 + + 9.2. Secondcasestudy: deviceindependent graphics + +299 + +9.2 Second case study: device independent graphics + +The (cid:2)rst case study used the X-windows system as its sole output device. In this +second case study we will develop a well engineered device driver. The X-windows +library offers functions for rendering boxes, circles, and so on, and there are func- +tion calls to initialise the X-windows library. All graphics systems have an inter- +face which has such a structure, but the details differ. In this section we will show +how to de(cid:2)ne a general interface that supports the various devices. + +We will (cid:2)rst develop an interface that has only limited functionality: it should +be possible to draw a line from one point to another. As soon as that has been +achieved, the functionality will be extended to cater for other primitives, such as +boxes, circles or text. The running example will consider two output devices: X- +windows and PostScript, but other devices can be added with relative ease. X +Windows was introduced in the previous chapter. It is a windowing system that +runs on almost any workstation. PostScript is a graphics language that is mainly +used to control the output of printers. We will give a brief description of PostScript +below. + +9.2.1 PostScript + +PostScript is a programming language. A PostScript program is speci(cid:2)ed in +ASCII. In order to render the graphics, the program need to be interpreted. +PostScript interpreters are found in printers, and in many windowing systems. +Note the difference with X: X graphics are drawn by calling a C function, +PostScript graphics are drawn by generating a bit of PostScript code. Consider +the following PostScript program: + +%!PS +newpath + +0 +0 moveto +0 100 lineto +100 100 lineto +100 +0 lineto +closepath +stroke +showpage + +The (cid:2)rst line %!PS declares this as a PostScript program. The second line starts a +new line drawing, called a path in PostScript. The moveto command moves the +current position to the point with coordinates (0,0). + +PostScript is a stack based language. This means that arguments are listed before +giving the name of the function for which the arguments are intended. PostScript +uses the standard Cartesian coordinate system, with the lower left corner of the +area that can be used for drawing at (0,0). This is thus different from X-windows, +which uses the top left hand corner of the image as point (0,0). Such differences +will be hidden by the device independent driver that we are about to develop. + +In the PostScript program above, the (cid:2)rst lineto command de(cid:2)nes a line + +Revision: 1.25 + + 300 + +Chapter9. Threecasestudies ingraphics + +from the current point, (0,0), to the new point (0,100). The next lineto de(cid:2)nes +a line from the current point, (0,100), to the point 100,100. The closepath com- +mand closes the path (de(cid:2)ning a line from the end to the starting point). The +stroke command actually draws a line through all the points along the path that +we have speci(cid:2)ed. The (cid:2)nal showpage command causes the output device to start +rendering all drawing and text on the current page. + +The PostScript unit is a point, which is (cid:2) + +(cid:0) of an inch. The PostScript program +above thus draws a square with its south west corner at the origin of the coordi- +nate system. The square has sides slightly larger than 1 inch. + +In all our examples we will print PostScript code in an output (cid:2)le. To render +such (cid:2)les, it must be viewed using a PostScript viewer (ghostview for example), +or it must be sent to a PostScript compatible printer. We will not discuss PostScript +in any more detail here, we refer the interested reader to the PostScript Reference +Manual [4]. + +9.2.2 Monolithic interface design + +To draw a line in X-windows we have to execute the following C function call: + +XDrawLine( display, window, gc, x1, y1, x2, y2 ) ; + +Here the display, window and graphics context are identi(cid:2)ed by display, +window and gc. The last four arguments identify the (integer) coordinates of the +begin and end point of the line. A PostScript program fragment to draw a line +reads: + +(cid:8)(cid:10)(cid:2) + +(cid:2) moveto +(cid:0) lineto + +(cid:8)(cid:10)(cid:2) + +and + +are the (real) coordinates of the begin and the end point of +Here +the line. The data structures and function that will draw a line in either PostScript +or X-windows should take into account the peculiarities of both X-windows and +PostScript. Here are the appropriate data structures, where X11 represents the X- +windows library and PS the PostScript format: + +#include +#include +#include + +#define X11HEIGHT 100 +#define X11WIDTH 100 + +typedef enum { X11, PS } Devicetype ; +typedef struct { + +Devicetype tag ; +union { + +struct { + +Display *d ; +Window w ; +GC gc ; + +Revision: 1.25 + +(cid:0) +(cid:2) +(cid:8) +(cid:0) +(cid:2) +(cid:1) +(cid:14) +(cid:2) +(cid:2) +(cid:8) +(cid:1) +(cid:8) +(cid:0) +(cid:14) +(cid:2) +(cid:0) +(cid:8) + 9.2. Secondcasestudy: deviceindependent graphics + +301 + +XtAppContext context ; +Widget widget ; + +} X11 ; +struct { + +FILE *out ; + +} PS ; + +} c ; +} Device ; + +The type Device captures the information about the device. +In this case there +are only two devices: X11, or PS. Speci(cid:2)c information pertaining to each device +is needed in the structure. For X-windows the display, window, graphics con- +text, application context and the widget to be used for graphics operation must +be stored. For PostScript we store a (cid:2)le descriptor. + +The line drawing function itself performs case analysis to decide which output + +device is appropriate: + +void draw_line( Device *d, + +int x0, int y0, int x1, int y1 ) { + +switch( d->tag ) { + +case X11: + +XDrawLine( d->c.X11.d, d->c.X11.w, d->c.X11.gc, + +x0, X11HEIGHT-1-y0, x1, X11HEIGHT-1-y1 ) ; + +break ; + +case PS: + +fprintf( d->c.PS.out, "newpath\n" ) ; +fprintf( d->c.PS.out, "%d %d moveto\n", x0, y0 ) ; +fprintf( d->c.PS.out, "%d %d lineto\n", x1, y1 ) ; +fprintf( d->c.PS.out, "closepath\n" ) ; +fprintf( d->c.PS.out, "stroke\n" ) ; +break ; + +default: + +abort() ; + +} + +} + +The function draw_line takes the device parameter, and uses the tag to (cid:2)nd out +whether to draw a line on the X screen, or whether to output PostScript code. The +code also does some transformations: X11 draws upside down (low Y values are +at the top of the drawing), while a low Y value in PostScript represents something +at the bottom of the drawing. These differences are hidden by the device driver. + +The example can be extended with other devices and more functions. For ex- +ample, the function shown below draws a box. The subtractions made in the ar- +guments to XDrawRectangle show how the device independence hides the dif- +ferences between the PostScript and X11 views on the coordinate systems: + +void draw_box( Device *d, + +int x0, int y0, int x1, int y1 ) { + +switch( d->tag ) { + +Revision: 1.25 + + 302 + +Chapter9. Threecasestudies ingraphics + +case X11: + +XDrawRectangle( d->c.X11.d, d->c.X11.w, d->c.X11.gc, +x0, X11HEIGHT-1-y0, x1-x0, y1-y0 ) ; + +break ; + +case PS: + +fprintf( d->c.PS.out, "newpath\n" ) ; +fprintf( d->c.PS.out, "%d %d moveto\n", x0, y0 ) ; +fprintf( d->c.PS.out, "%d %d lineto\n", x0, y1 ) ; +fprintf( d->c.PS.out, "%d %d lineto\n", x1, y1 ) ; +fprintf( d->c.PS.out, "%d %d lineto\n", x1, y0 ) ; +fprintf( d->c.PS.out, "%d %d lineto\n", x0, y0 ) ; +fprintf( d->c.PS.out, "closepath\n" ) ; +fprintf( d->c.PS.out, "stroke\n" ) ; +break ; + +default: + +abort() ; + +} + +} + +The extension of the device independent driver with a box primitive is not much +work. However, each time that another device has to be added, both functions +draw_line and draw_box need to be modi(cid:2)ed. This is not much work in the +case of two functions, but with 15 primitive elements it becomes clear that this so- +lution lacks structure: each function contains information about every device. This +means that information about one particular device is scattered over all functions, +and implementation of a new device will require the modi(cid:2)cation of all functions. + +9.2.3 Modular interface design + +A better way to build a general interface to graphics devices is to insert a new level +of abstraction. Looking from an abstract viewpoint, a library to draw pictures on +some output device consists of a set of functions for drawing the various primitive +elements. For example: + +draw box +draw line +draw circle +draw ellipse + +lower left +from +centre +centre + +upper right +to +radius +radii + +(cid:8)(cid:10)(cid:2) + +(cid:0) and (cid:0) + +To manipulate a set of functions such as those listed above we need a data struc- +ture that holds them together. In SML we could de(cid:2)ne the data structure as fol- +lows: + +datatype (cid:146)a graphics += DrawBox of +| DrawLine of +| DrawCircle of ((cid:146)a * int * int * int -> (cid:146)a) +| DrawEllipse of ((cid:146)a * int * int * int * int -> (cid:146)a) ; + +((cid:146)a * int * int * int * int -> (cid:146)a) +((cid:146)a * int * int * int * int -> (cid:146)a) + +Revision: 1.25 + +(cid:1) +(cid:8) +(cid:1) +(cid:14) +(cid:2) +(cid:1) +(cid:8) +(cid:1) +(cid:8) +(cid:2) +(cid:14) +(cid:2) +(cid:2) +(cid:8) +(cid:1) +(cid:8) +(cid:1) +(cid:14) +(cid:2) +(cid:1) +(cid:8) +(cid:1) +(cid:14) +(cid:2) +(cid:2) +(cid:8) +(cid:1) +(cid:8) +(cid:14) +(cid:2) +(cid:8) +(cid:0) +(cid:1) +(cid:8) +(cid:14) +(cid:2) +(cid:8) +(cid:0) +(cid:0) + 9.2. Secondcasestudy: deviceindependent graphics + +303 + +This data type stores functions to draw a box, a line, a circle and an ellipse. It takes +something of type (cid:146)a (an array of pixels or something else), and it produces a new +version of (cid:146)a . The designer of a graphics device will have to implement the func- +tions needed to render lines, boxes, and so on, and will create a data structure of +the type graphics which contains these four functions. The user of the graph- +ics library will simply use one of the available graphics structures, and call the +functions. + +The SML data structure is not complete; an extra open function is needed to +create an initial value for (cid:146)a , and also a close function is needed. The full de(cid:2)ni- +tion of the SML device driver would read: + +graphics + +datatype ((cid:146)a,(cid:146)b,(cid:146)c) += Open of +| DrawBox of +| DrawLine of +| DrawCircle of ((cid:146)a * int * int * int -> (cid:146)a) +| DrawEllipse of ((cid:146)a * int * int * int * int -> (cid:146)a) +| Close of + +((cid:146)b -> (cid:146)a) +((cid:146)a * int * int * int * int -> (cid:146)a) +((cid:146)a * int * int * int * int -> (cid:146)a) + +((cid:146)a -> (cid:146)c) ; + +Here (cid:146)b is a device dependent data type containing information on how to open +the device (for example the size and position of a window, or the (cid:2)lename for a +postscript (cid:2)le). Similarly (cid:146)c is a device dependent type containing any informa- +tion that remains after the last object has been drawn. + +The graphics structure can be translated into C, where we use the state hid- +ing principles of the previous chapter. The function open will allocate the state, +and return a pointer to it, the other functions will receive this pointer, and modify +the state when appropriate. The close function in C explicitly deallocates stor- +age, because C has explicit memory management. + +typedef struct { + +void *(*open)( void *what ) ; +void (*draw_line)( void *g, int x0, int y0, + +void (*draw_box)( void *g, int x0, int y0, + +int x1, int y1 ) ; + +int x1, int y1 ) ; + +/*C Other elements of device driver*/ +void (*close)( void *g ) ; + +} graphics_driver ; + +Exercise 9.3 Add support for drawing circles and ellipses to the device driver + +structure. + +Exercise 9.4 What is the most important difference between the SML and the C + +data structure? + +For any speci(cid:2)c graphics library we need to specify the functions to perform these +primitive operations, and a structure containing the pointers to these functions. + +Revision: 1.25 + + 304 + +Chapter9. Threecasestudies ingraphics + +So, we can now de(cid:2)ne the following module for the X11 driver: + +#include "X11driver.h" +#include +#include +#include +#include + +typedef struct { +Display *d ; +Window w ; +GC gc ; +XtAppContext context ; +Widget widget ; + +} X11Info ; + +#define HEIGHT 100 +#define WIDTH 100 + +void *X11_open( void *what ) { + +X11Info *i = malloc( sizeof( X11Info ) ) ; +X11Open *args = what ; +long black ; +XSetWindowAttributes attrib ; +i->widget = XtVaAppInitialize( &i->context, "XProg", NULL, + +0, args->argc, args->argv, +NULL, NULL ) ; + +XtVaSetValues( i->widget, XtNheight, HEIGHT, + +XtNwidth, WIDTH, NULL ) ; + +XtRealizeWidget( i->widget ) ; +i->d = XtDisplay( i->widget ) ; +i->w = XtWindow( i->widget ) ; +i->gc = XCreateGC( i->d, i->w, 0, NULL ) ; +black = BlackPixel( i->d, DefaultScreen( i->d ) ) ; +XSetForeground( i->d, i->gc, black ) ; +attrib.backing_store = Always ; +XChangeWindowAttributes( i->d, i->w, CWBackingStore, &attrib) ; +return (void *) i ; + +} + +void X11_draw_line( void *g, + +int x0, int y0, int x1, int y1 ) { + +X11Info *i = g ; +XDrawLine( i->d, i->w, i->gc, x0, HEIGHT-1-y0, + +x1, HEIGHT-1-y1 ) ; + +} + +Revision: 1.25 + + 9.2. Secondcasestudy: deviceindependent graphics + +305 + +void X11_draw_box( void *g, + +int x0, int y0, int x1, int y1) { + +X11Info *i = g ; +XDrawRectangle( i->d, i->w, i->gc, x0, HEIGHT-1-y0, +x1-x0, y1-y0 ) ; + +} + +void X11_close( void *g ) { + +X11Info *i = g ; +XFreeGC( i->d, i->gc ) ; +XtAppMainLoop( i->context ) ; +free( i ) ; + +} + +graphics_driver X11Driver = { + +X11_open, +X11_draw_line, +X11_draw_box, +/*C other functions of the driver*/ +X11_close + +} ; + +The interface of the module exports the driver information, that is the structure +of the type graphics_driver. It also exports the de(cid:2)nition of the structure that +de(cid:2)nes which parameters must be passed to open the device, in this case a pointer +to the argument count and the argument vectors: + +#ifndef X11_DRIVER_H +#define X11_DRIVER_H + +extern graphics_driver X11Driver ; + +typedef struct { +int *argc ; +char **argv ; + +} X11Open ; + +#endif /* X11_DRIVER_H */ + +Exercise 9.5 Add support for drawing circles and ellipses to the X11 device driver. + +Exercise 9.6 De(cid:2)ne the appropriate data structure and functions for the Postscript + +driver. + +To use the device independent graphics, we need to pass structures of type +graphics_driver around. Here is a function that draws a cross, using the + +Revision: 1.25 + + 306 + +Chapter9. Threecasestudies ingraphics + +draw_line primitives from the driver: + +void draw_cross( graphics_driver *g, void *openinfo ) { + +void *driver = (*g->open)( openinfo ) ; +(*g->draw_line)( driver, 0, 0, 100, 100 ) ; +(*g->draw_line)( driver, 100, 0, 0, 100 ) ; +(*g->close)( driver ) ; + +} + +int main( int argc, char *argv[] ) { + +X11Open arguments ; +arguments.argc = &argc; +arguments.argv = argv ; +draw_cross( &PSDriver, "out.ps" ) ; +draw_cross( &X11Driver, &arguments ) ; +return 0 ; + +} + +The device independent graphics drivers have been developed using all the tech- +niques that we encountered earlier: extra arguments (Section 4.5), higher order +functions (Section 2.5), structured data types (Chapter 4), and handling state (Sec- +tion 8.4). This has now resulted in a well engineered module of code. Just to list +some of the properties of this module: + +(cid:1) Drivers are coded in separate modules. The advantage of this is that mainte- +nance and development of code are decoupled, and that different people can +develop drivers independently. The localisation of errors is also easier. + +Instances of different drivers can be used simultaneously. It is possible for a +program to use both a PostScript driver and an X11 driver at the same mo- +ment in time. A monolithic design does not necessarily have this property: +it might use global variables that are shared between the drivers, which will +result in run time chaos when the two drivers are used simultaneously. + +If the device allows it, multiple instances of the same driver can be opened +simultaneously. For example, output can be generated on three postscript +(cid:2)les at the same time. A design that would use global variables in the mod- +ules, for example FILE *out as a static variable in the module PostScript, +would support only one (cid:2)le at a time. + +Exercise 9.7 It is possible to write a PostScript fragment that is to be included in +another PostScript program (for examples a (cid:2)gure in a book). This so called +encapsulated PostScript needs a bounding box which speci(cid:2)es how big the +picture is. The bounding box is speci(cid:2)ed in PostScript program in the fol- +lowing way: + +%%BoundingBox: (cid:8) + +(cid:8)(cid:10)(cid:2) + +Revision: 1.25 + +(cid:1) +(cid:1) +(cid:1) +(cid:2) +(cid:1) +(cid:2) +(cid:2) + 9.3. Thirdcasestudy: agraphicslanguage + +307 + +is the coordinate of the lower left hand corner and + +Here +is +the coordinate of the upper right hand corner of the (cid:2)gure. Modify the +PostScript driver so that the bounding box is maintained (in the PSInfo +structure), and printed just before the (cid:2)le is closed. To be properly under- +stood by PostScript interpreters you must print a line + +(cid:8)(cid:15)(cid:2) + +%%BoundingBox: (atend) + +Immediately after the %!PS line in the beginning. + +Exercise 9.8 The computer system that you have access to may have a native +graphics system that is different from X11 or PostScript. Develop a device +driver that interfaces to the native graphics system. + +Exercise 9.9 Enhance the graphics driver to allow the use of colour. + +Exercise 9.10 Rewrite the fractal program of our (cid:2)rst case study to use the de- +vice independent graphics library. Check the PostScript output of your pro- +gram. + +9.3 Third case study: a graphics language + +We have now discussed how a device independent library of graphics primitives +for boxes, circles and lines can be built. This library can be used directly from a C +program that intends to create some graphics. However, the library functions are +still quite low level because bookkeeping is required to place and size the lines, +circles and boxes appropriately. This can be especially cumbersome when a com- +plicated picture is created out of a large number of primitive graphical objects. + +As our third case study we are going to de(cid:2)ne a graphics programming lan- +guage for creating line drawings. In addition we will develop a C program, gp, +that interprets programs written in the graphics language to draw pictures on an +output device of our choice. The program will use the device independent graph- +ics library. + +We will develop a working skeleton of the language. Not all features are imple- +mented, but the reader is encouraged to add these features. Still, developing this +skeleton is not a trivial task: we will have to use some advanced programming +techniques which are not covered in this book. We explain these techniques, lexi- +cal analysis and parsing, on a need-to-know basis. Books such as the ‘red dragon +book’ [1] on compiler construction, automata, and languages give an in depth cov- +erage of these techniques. + +Here is a picture showing the result of using gp. The picture has a dual pur- +pose. Firstly it shows the style of line drawings that we will be able to produce. +Secondly it symbolises the working of the graphics interpreter gp itself: + +(cid:2)le + +gp + +device + +Revision: 1.25 + +(cid:1) +(cid:8) +(cid:1) +(cid:14) +(cid:2) +(cid:1) +(cid:8) +(cid:1) +(cid:14) +(cid:2) +(cid:2) +(cid:8) + 308 + +Chapter9. Threecasestudies ingraphics + +Examining the picture from left to right we encounter a circle labeled with the text +file. This says that we have to create a (cid:2)le containing a graphics program. This +(cid:2)le is then read and interpreted by the graphics processor program, as symbol- +ised by the box labeled with the text gp. Finally, the result of the interpretation is +shown on an appropriate output device, which is indicated by the circle labeled +device. + +The graphics language that we will use to create the picture is essentially a sim- +pli(cid:2)ed and stylised version of the paragraph of text above. The following are the +most important elements of the description: + +(cid:1) The English description mentions the graphic primitives box and circle. + +(cid:1) The texts "file", "gp" and "device" are used as labels of these three + +primitives. + +(cid:1) Lines are used to connect the primitives. + +(cid:1) As we are used to reading English text from left to right, we will also assume + +that pictures in our graphics language are described from left to right. + +With these considerations in mind, the following graphics program seems to be a +reasonable and succinct description of our picture: + +.PS +circle "file" ; +line ; +box "gp" ; +line ; +circle "device" +.PE + +The box and the circle are labeled by writing the text of the label (in double +quotes) next to the primitives as attributes. The two line primitives take care of +the connections. We will call a primitive with its associated attributes an element. +Then all elements are separated by semi colons and as a (cid:2)nishing touch, the key- +words .PS and .PE indicate the start and the end of the graphics program. + +The graphics programming language as we have describe here is actually a +sub-set of the PIC language designed by Brian Kernighan [6], and our gp program +will be a tiny version of the full implementation of the PIC language. + +To build an interpreter for a language is a non trivial task because it requires +the interpreter (in our case the gp program) to understand the meaning of the +words and the sentences of the language. We can identify the following tasks in- +volved in this process of understanding: + +lex Recognising the words of the language, such as box, "file", ; and .PS, +where a word consists of a sequence of characters. This (cid:2)rst task is called +the lexical analysis or lexing for short. + +parse Recognising the sentences of the language, such as circle "file" ;, +where the sentences consist of sequences of words. This second task is called +parsing. + +Revision: 1.25 + + 9.3. Thirdcasestudy: agraphicslanguage + +309 + +interpret Interpreting the individual sentences in such a way that they form part + +of a whole: the picture. + +Using our graphics language to describe these three tasks and their relationship +we arrive at the following structure: + +char + +read + +lex + +token + +parse + +element + +interpret + +command + +device + +In the following sections we will look at these three tasks and set a number of in- +teresting exercises. When worked out successfully they create a complete gp pro- +gram capable of drawing pictures, of which we have already seen many examples. +Several more examples will follow shortly. + +9.3.1 Lexical analysis + +The graphics language has four different kinds of words, of which we have al- +ready seen three categories: + +ident (short for identi(cid:2)er). Examples are circle and .PS. + +symbol such as ;. + +text enclosed in double quotes, such as "file". + +number It seems a good idea to include also real numbers in our graphics lan- +guage, as they will be handy for creating primitives of a speci(cid:2)c size and +movements over a certain distance. An example of a number is 3.1415. + +error We have now essentially decided upon the possible form of the words that +we admit to our language. However, a well designed program should al- +ways be able to deal with incorrect input. To cater for this we add a further +category of words that represent erroneous input. Some examples are: @#%$ +and 3.A + +Now we can de(cid:2)ne a data structure to represent all possible words, which is con- +ventionally called a token. Here is the SML version of the data structure: + +datatype token = Number of real + +| Ident of string +| Text +of string +| Symbol of string +| Error ; + +Revision: 1.25 + + 310 + +Chapter9. Threecasestudies ingraphics + +Exercise 9.11 De(cid:2)ne a C data structure token that is equivalent to the SML +token, above. Create malloc based functions to dynamically allocate +structs of the appropriate form and contents and create a set of access +functions. Package the data structure and its house keeping functions in a +module with a clean interface. + +A graphics program, like most other programs, is stored in a (cid:2)le as a sequence of +characters. The token data structure represents the words of the language, and +we have seen that the words are individual sequences of characters. Our next task +therefore is to write a function that when given a sequence of characters produces +a sequence of tokens: the lexical analysis. + +Interestingly, lexical analysis can be described accurately using a picture of the +kind that our graphics language is able to create! Here is the process depicting +the recognition of real numbers. The circles represent the fact that the recognising +process is in a particular state and the arrows represent transitions from one state +to the next. + +mantissa + +(cid:23)(cid:26)% + ++* + +(cid:16)(cid:18)(cid:16)(cid:18)(cid:16) + +(cid:23)(cid:26)% + +(cid:16)(cid:18)(cid:16)(cid:18)(cid:16) + +(cid:23)(cid:26)% + ++* + +(cid:16)(cid:18)(cid:16)(cid:21)(cid:16) + +start +here + +lex + +(cid:23)(cid:26)% + ++* + +(cid:16)(cid:18)(cid:16)(cid:18)(cid:16) + +fraction + +(cid:23)(cid:26)% + ++* + +(cid:16)(cid:18)(cid:16)(cid:18)(cid:16) + +Recognising a real number is done by interpreting the picture as a road map and +using the input characters for directions. If we start in the state labeled lex then +we can only move to the state mantissa if a digit in the range (cid:23)(cid:26)% +is seen in +the input. In the state mantissa, further digits can be accepted, each returning into +the current state. As indicated by the two remaining arrows, there are two ways +out of the state mantissa. When a full stop is seen we move to the state fraction +and when some other character is seen, we move back to the initial state lex. In +the state fraction we will accept further digits, but when encountering something +else than a digit we return to the initial state. The result of a journey using the +road map is the collection of characters that have been accepted. This collection +represents the current word or token. + +(cid:16)(cid:21)(cid:16)(cid:18)(cid:16) + ++* + +Revision: 1.25 + +(cid:27) +(cid:2) +(cid:0) +(cid:3) +(cid:13) +(cid:27) +(cid:2) +* +’ +(cid:13) +(cid:0) +(cid:3) +(cid:27) +(cid:2) +(cid:27) +(cid:2) +(cid:13) +(cid:27) +(cid:2) +(cid:2) + 9.3. Thirdcasestudy: agraphicslanguage + +311 + +A ‘road map’ such as the one above is called a state transition diagram. Similar +diagrams can be made for recognising the other tokens of the language; here is +another state transition diagram that deals with layout characters, such as spaces +(cid:2)(cid:1) ). +(shown as (cid:0) ) and new lines (shown as (cid:0) + +start +here + +lex + +(cid:2)(cid:1) + +(cid:3)(cid:0) + +Exercise 9.12 Draw the state transition diagrams for the recognition of ident, + +text, symbol and error. +ident An identi(cid:2)er begins with a letter or a full stop (.), which is then + +followed by zero or more letters or digits. + +text A text is an arbitrary sequence of characters enclosed in double + +quotes (");. + +symbol A symbol can be either a semi colon (;) or an equal sign (=). +error When anything else is encountered, an error token is returned. + +The state diagrams are combined into one by making the lex circle common to all +diagrams. If the individual diagrams have been designed properly, there should +be a number of arcs out of the lex circle, but no two should carry a label with +the same character attached. Furthermore, all possible characters should be dealt +with. The error token is used to achieve this: + +(cid:16)(cid:18)(cid:16)(cid:21)(cid:16) + +(cid:16)(cid:18)(cid:16)(cid:21)(cid:16) + +(cid:5)(cid:4) + +(cid:23)(cid:26)% + ++* + +start +here + +lex + +(cid:6)(cid:1) + +(cid:3)(cid:0) + +error + +Exercise 9.13 Write a C function lex that implements the combined state transi- +tion diagram for the lexical analyser of our graphics language. The function +lex should take its input from stdin. +Gather lex and its auxiliary functions in a module, but make sure that only +lex and the token type are exported through the interface. + +Exercise 9.14 With the lexical analyser in place it should be possible to write a +small test program that reads characters from stdin to produce a sequence +of tokens. Print the tokens one per line. + +Revision: 1.25 + +(cid:27) +(cid:23) +(cid:0) +* +(cid:27) +(cid:23) +(cid:0) +(cid:5) +* +(cid:27) +(cid:23) +(cid:0) +* +(cid:27) +(cid:2) +(cid:27) +(cid:23) +(cid:0) +* +(cid:27) +(cid:23) +(cid:16) +* +(cid:27) +(cid:23) +(cid:11) +(cid:11) +* + 312 + +Chapter9. Threecasestudies ingraphics + +9.3.2 Parsing + +The lexical analysis delivers a stream of tokens, one for each call to the function +lex. So now is the time to gather selected tokens into larger units that correspond +to the sentences of the language. To make life easier for the interpreter we will de- +(cid:2)ne a number of data types that describe the relevant sentences and sub sentences +of the graphical language. + +Here is the SML data type de(cid:2)nition of the graphical primitives: + +datatype primitive = Box | Circle | Line ; + +To allow for some (cid:3)exibility in the graphics language we allow for expressions that +consist of either an identi(cid:2)er or a number: + +datatype expression = Ident of string +| Number of real ; + +With a primitive we would like to associate not only its text label, but also whether +it should have a particular height, width or radius. This gives rise to the following +SML data type de(cid:2)nition for an attribute of a graphics primitive: + +datatype attribute = Height of expression +| Width of expression +| Radius of expression +| Text + +of string ; + +We are now ready to de(cid:2)ne the data type for the elements (that is, the sentences of +the graphics language): + +datatype element = Up + +| Down +| Right +| Left +| Assign of string * expression +| Prim + +of primitive * attribute list ; + +The element data type allows for six different kinds of sentences. The (cid:2)rst four +are intended to move to a particular position before beginning to draw the next ob- +ject. The Assign constructor associates an identi(cid:2)er (represented here as a string +of characters) with an expression. This will enable us to give a name to an expres- +sion and refer to that name wherever the value of the expression is required. The +last element is the most interesting for it associates a graphics primitive with its +list of attributes. + +Exercise 9.15 Create a module that de(cid:2)nes the data structures in C to represent +the primitive, expression, attribute and element. These should +be heap allocated structures. + +The de(cid:2)nition of an element would allow us to write (in SML): +val box_primitive = Prim(Box,[Text "a box", + +Height (Number 3.0)]); + +Revision: 1.25 + + 9.3. Thirdcasestudy: agraphicslanguage + +313 + +The corresponding list of tokens returned by our lexical analyser would be (also in +SML): + +val box_tokens = [Ident ".PS", +Ident "box", +Text +Ident "height", +Number 3.0, +Ident ".PE" ]; + +"\"a box\"", + +The task of the parser is to gather the tokens in such a way that they fall in the right +place in the right (that is, primitive, expression, attribute or element) +data structure. To achieve this we will use the same technique of state transition +based recognition as with the lexical analyser. Firstly, we draw a series of road +maps. Here is the state diagram for a primitive. It shows that a primitive can only +be one of the three identi(cid:2)ers "box", "circle", or "line": + +primitive: + +"box" + +"circle" + +"line" + +An expression can be an identi(cid:2)er or a number, where any particular identi(cid:2)er or +number is acceptable. This is indicated by just mentioning states ident and num- +ber. These refer to the tokens of the same name as delivered by the lexical analyser. + +expression: + +ident + +number + +An attribute is more interesting. It consists of a series of alternatives, of which the +(cid:2)rst three have to consist of two items: + +attribute: + +"height" + +expression + +"width" + +expression + +"radius" + +expression + +text + +Revision: 1.25 + + 314 + +Chapter9. Threecasestudies ingraphics + +An element is also one of a series of alternatives. A primitive may be followed by +zero or more attributes; an assignment must consist of three consecutive items and +the moves consist of just the words up, down, left and right. + +attribute + +element: + +primitive + +ident + +"=" + +expression + +"up" + +"down" + +"left" + +"right" + +A gp program consists of a list of elements, separated by semi colons and sur- +rounded by the words .PS and .PE: + +";" + +program: + +".PS" + +element + +".PE" + +Exercise 9.16 Write one parse function for each of primitive, attribute, +expression, element, and program. Each parse function should call +upon lex to retrieve token(s) from the stdin stream. Based upon the to- +ken received, your parse functions should decide what the next input sen- +tence is, and return a pointer to the struct of the appropriate type and +contents. + +Exercise 9.17 Write a main function that uses lex and the parse functions to read +a gp program from stdin and to create a representation of the program +in the heap as a list of elements. Write a printing function for each of the +data structures involved and use this to print the heap representation of a +gp program. + +Revision: 1.25 + + 9.3. Thirdcasestudy:agraphicslanguage + +315 + +9.3.3 Interpretation + +We have now at our disposal a library of device independent graphics primitives +and the lexing and parsing tools to create a structured, internal representation of +a gp program in the heap. To combine these elements we need to write an in- +terpreter of the internal representation of the program, that calls the appropriate +library routines. Before we can embark on this two further explanations of how +gp works. + +Firstly, the program has a notion of a current point and a current direction. By +default the current direction is right, but it can be modi(cid:2)ed by one of the com- +mands up, down, left or right. + +The current point will be aligned with a particular corner or point of the next +graphical object to be drawn. Let us assume for now that the current direction is +right. The current point is then aligned with: + +line The begin point of the line. + +box The middle of the left vertical. + +circle The left intersect of the circle and a horizontal line through its centre. + +The small circles in the picture below give a graphical indication of the alignment +points. + +line: + +box: + +direction + +direction + +circle: + +direction + +The alignment point is thus as far away from the point to which we are mov- +ing. This also applies to moves in one of the other three directions. For example, +should we be moving upwards, the alignment point is below the object, instead of +its left. + +Secondly, the gp program maintains a set of variables that control the default +dimensions of the primitive objects, as well as the default moving distances. These +variables can be set using assignment statements. The variables and their initial +settings (in inches) are: + +.PS += 0.5 ; +boxht +boxwid += 0.75 ; +circlerad = 0.25 ; += 0.5 ; +lineht += 0.5 ; +linewid + +Revision: 1.25 + + 316 + +Chapter9. Threecasestudies ingraphics + +moveht +movewid +textht +textwid +.PE + += 0.5 ; += 0.5 ; += 0.0 ; += 0.0 + +The default width of a box is 0.75 inches and its default height is 0.5 inches. The +default can be overridden either by changing the value of the appropriate variable +using an assignment, or by using explicit attributes to state the sizes, so that for +example: box width 0.5 draws a square, and so does this gp program: + +.PS +boxwid = boxht ; +box +.PE + +Exercise 9.18 Implement the interpreter for the internal representation of a gp + +program. + +The gp language can be extended with a large variety of useful constructs. The +exercises at the end of this chapter provide a number of suggestions. + +9.4 Summary + +Programming graphics systems is rewarding, but it also a dif(cid:2)cult topic that is +worthy of study on its own. In this chapter we have merely hinted at some of the +possibilities of computer graphics. Three case studies have been made to show +how the principles of programming as we have developed them in this book are +used in practice. The most important practical points are: + +(cid:1) Use separate modules whenever possible. Modularisation structures the +program and allows independent development, testing and maintenance. + +(cid:1) Hide platform and machine dependencies (for example graphics libraries) in + +separate modules. + +(cid:1) Use higher order functions when appropriate. Writing device drivers using + +higher order functions simpli(cid:2)es the structure of the program. + +(cid:1) To create your design use a language with polymorphic types. Then translate + +the design into C, using void * if necessary. + +9.5 Further exercises + +Exercise 9.19 Extend the expressions of the gp language with the usual arithmetic + +operators, such as +, -, * and / and with parentheses ( and ). + +Revision: 1.25 + + 9.5. Furtherexercises + +317 + +Exercise 9.20 Extend the language so that the movements up, down, left and +right will take attributes, in the same way as a primitive takes attributes. + +Exercise 9.21 Add to the elements a construct that makes it possible to repeatedly + +draw a certain object or set of objects: + +.PS +for i = 1 to 6 do { + +box width 0.1 height 0.2 ; +right (0.05*i*i) ; +up 0.1 + +} +box width 0.1 height 0.2 ; +.PE + +Exercise 9.22 Add a new primitive: ellipse. Also extend the set of default sizes: + +.PS +ellipseht = 0.5 ; +ellipsewid = 0.75 ; +ellipse "an" "ellipse" +.PE + +an +ellipse + +Exercise 9.23 Introduce an attribute that allows objects to be drawn in colour. + +Revision: 1.25 + + 318 + +Chapter9. Threecasestudies ingraphics + +Revision: 1.25 + + c(cid:0) + +1995,1996 Pieter Hartel & Henk Muller, all rights reserved. + +Bibliography + +[1] A. V. Aho, R. Sethi, and J. D. Ullman. Compilers: Principles, techniques, and + +tools. Addison Wesley, Reading, Massachusetts, 1986. + +[2] J. L. Hennessy and D. A. Patterson. Computer architecture: A quantitative ap- +proach. Morgan Kaufmann Publishers, Inc., San Mateo, California, 1990. + +[3] C. A. R. Hoare. Algorithm 64 quicksort. CACM, 4(7):321, Jul 1961. + +[4] Adobe Systems Inc. PostScript language reference manual. Addison Wesley, + +Reading, Massachusetts, 1985. + +[5] R. Jain. + +The art of Computer Systems Performance Analysis. + +John Wiley, + +Newyork, 1991. + +[6] B. W. Kernighan. PIC (cid:151) a language for typesetting graphics. Software(cid:151) + +practice and experience, 12(1):1(cid:150)21, Jan 1982. + +[7] B. W. Kernighan and D. W. Ritchie. The C programming language - ANSI C. +Prentice Hall, Englewood Cliffs, New Jersey, second edition edition, 1988. + +[8] D. E. Knuth. The art of computer programming, volume 1: Fundamental algo- + +rithms. Addison Wesley, Reading, Massachusetts, second edition, 1973. + +[9] L. C. Paulson. ML for the working programmer. Cambridge Univ. Press, New + +York, 1991. + +[10] W. H. Press, B. P. Flannery, S. A. Tekolsky, and W. T. Vetterling. Numerical +recipes in C (cid:150) The art of scienti(cid:2)c computing. Cambridge Univ. Press, Cambridge, +England, 1993. + +[11] B. Schneier. Applied cryptography. +second edition edition, 1996. + +John Wiley & Sons, Chichester, England, + +[12] R. Sedgewick. Algorithms. Addison Wesley, Reading, Massachusetts, 1983. + +[13] E. H. Spafford. The internet worm program: an analysis. ACM Computer + +communication review, 19(1):17(cid:150)??, Jan 1989. + +[14] A. S. Tanenbaum. Structured computer organisation. Prentice Hall, Englewood + +Cliffs, New Jersey, second edition, 1984. + +319 + + 320 + +BIBLIOGRAPHY + +[15] J. D. Ullman. Elements of ML programming. Prentice Hall, Englewood Cliffs, + +New Jersey, 1994. + +[16] A. Wikstr¤om. Functional programming using Standard ML. Prentice Hall, Lon- + +don, England, 1987. + +[17] X-Consortium. X Window Manuals. O’Reilly & Associates, Inc., New York, + +1990. + +Revision: 1.25 + + c(cid:0) + +1995,1996 Pieter Hartel & Henk Muller, all rights reserved. + +Appendix A + +Answers to exercises + +Below are the answers to a selection of the exercises in this book. For almost any +exercise, there is more than one correct answer, as there are many algorithms and +datastructures that implement a program. The answers that are presented here are +the ones that we consider the most appropriate. + +Answers to the exercises of Chapter 2 + +Answer to 2.1: The function euclid is called 5 times. A complete trace is: +euclid( 558, 198 ) is +euclid( 198, 162 ) is +euclid( 162, 36 ) is +euclid( 36, 18 ) is +euclid( 18, +0 ) is +18 + +Answer to 2.2: The general SML function schema for a cascade of (cid:0) conditionals +is: +(*SML general function schema*) + +(* (cid:0) : (cid:1)(cid:3)(cid:2) -> ... (cid:1)(cid:5)(cid:4) -> (cid:1)(cid:7)(cid:6) *) +fun (cid:0)(cid:9)(cid:8)(cid:10)(cid:2) ... (cid:8)(cid:11)(cid:4) += if (cid:12) + +then (cid:13) +else if (cid:12) + +then (cid:13) + +... +else if (cid:12) + +then (cid:13) +else (cid:14) ; + +The arguments of (cid:0) are (cid:8) +pressions (cid:12)(cid:17)(cid:2)(cid:17)(cid:16)(cid:18)(cid:16)(cid:18)(cid:16) +sions over the arguments of (cid:0) + +(cid:2)(cid:11)(cid:16)(cid:18)(cid:16)(cid:18)(cid:16)(cid:3)(cid:8)(cid:20)(cid:4) , and their types are (cid:1) + +are predicates over the arguments of (cid:0) + +(cid:2)(cid:17)(cid:16)(cid:18)(cid:16)(cid:21)(cid:16)(cid:22)(cid:1)(cid:7)(cid:4) respectively. The ex- +and (cid:14) are expres- + +, (cid:13)(cid:11)(cid:2)(cid:17)(cid:16)(cid:18)(cid:16)(cid:18)(cid:16)(cid:7)(cid:13) + +. + +321 + +(cid:2) +(cid:2) +(cid:0) +(cid:0) +(cid:1) +(cid:1) +(cid:12) +(cid:1) +(cid:1) + 322 + +AppendixA. Answerstoexercises + +The corresponding general C function schema is: + +/*C general function schema*/ + +(cid:8)(cid:20)(cid:4) ) { + +(cid:1)(cid:7)(cid:6) + +(cid:0) ( (cid:1)(cid:3)(cid:2) +if( (cid:12) + +(cid:8)(cid:10)(cid:2) , ... (cid:1)(cid:5)(cid:4) +(cid:2) ) { +return (cid:13) +} else if( (cid:12) +return (cid:13) +... + +(cid:0) ; + +(cid:2) ; + +(cid:0) ) { + +} else if( (cid:12) +return (cid:13) + +; + +) { + +} else { + +return (cid:14) ; + +} + +} + +Answer to 2.3: +function schema of the previous exercise. + +(cid:0) Here is the table of correspondence for eval, using the general + +schema: Functional + +: +(cid:1)(cid:3)(cid:2) : +(cid:1)(cid:1)(cid:0) : +: +: +(cid:5) : +(cid:1)(cid:7)(cid:6) : +(cid:8)(cid:10)(cid:2) : +(cid:0) : +: +: +(cid:5) : +(cid:2) : +(cid:0) : +: +: +(cid:2) : +(cid:0) : +: +: + +: + +C +eval +int +char +int +char +int +int +x +o1 +y +o2 +z + +eval +int +char +int +char +int +int +x +o1 +y +o2 +z +o1 = "+" andalso o2 = "+" o1 == (cid:146)+(cid:146) +o1 = "+" andalso o2 = "*" o1 == (cid:146)+(cid:146) +o1 = "*" andalso o2 = "+" o1 == (cid:146)*(cid:146) +o1 = "*" andalso o2 = "*" o1 == (cid:146)*(cid:146) +(x + y) + z +x + (y * z) +(x * y) + z +(x * y) * z : int +raise Match + +&& o2 == (cid:146)+(cid:146) +&& o2 == (cid:146)*(cid:146) +&& o2 == (cid:146)+(cid:146) +&& o2 == (cid:146)*(cid:146) + +(x + y) + z +x + (y * z) +(x * y) + z +(x * y) * z +/*raise Match*/ + +Answer to 2.5: The program will print the following line: + +(cid:146)0(cid:146) + += 48, (cid:146)q(cid:146) + += 113 + +Revision: 6.47 + +(cid:1) +(cid:1) +(cid:0) +(cid:1) +(cid:5) +(cid:1) +(cid:3) +(cid:1) +(cid:8) +(cid:8) +(cid:5) +(cid:8) +(cid:3) +(cid:8) +(cid:12) +(cid:12) +(cid:12) +(cid:5) +(cid:12) +(cid:3) +(cid:13) +(cid:13) +(cid:13) +(cid:5) +(cid:13) +(cid:3) +(cid:14) + 323 + +The primes, spaces, equals, and \n in the format string are printed literally. The +%c and %d formats are replaced by character and integer representations of the ar- +guments. The (cid:2)rst %c requires a character argument, c0; this is the character (cid:146)0(cid:146) +. +The %d format requires an integer, i0, which contains the integer representation +, which is 48. The second %c requires a character argument again, cq; this +of (cid:146)0(cid:146) +is the character which is represented by the integer 113, which is (cid:146)q(cid:146) +. The last %d +requires an integer, iq, which contains the integer 113. + +(cid:1)(cid:0) + +, (cid:0) + +Answer to 2.6: The second de(cid:2)nition of (cid:0) + +(cid:1) requires 8 multiplications: to calculate +has to be calculated and squared. Therefore it is one multiplication plus +, one mul- +(cid:0) . Finally, + +the number of multiplications needed to calculate (cid:0) +tiplication is needed, plus the number of multiplications to calculate (cid:0) +one multiplication is needed to calculate (cid:0) + +. To calculate (cid:0) + +(cid:2) . + +(cid:2)(cid:0) + +(cid:3)(cid:0) + +In general, the number of multiplications to calculate (cid:0)(cid:2)(cid:1) + +is bound by (cid:0) + +(cid:2)(cid:5) + +, + +as opposed to (cid:12) + +(cid:0) when one just applies a repeated multiplication. + +Answer to 2.7: Proof of the hypothesis (cid:0) +is de(cid:2)ned according to (2.4): + +(cid:8)(cid:5)(cid:9) + +(cid:0) by induction over (cid:12) + +, where (cid:0) + +Case (cid:0) : + +Case (cid:12) + +(cid:0) , with (cid:12)(cid:5)(cid:2) + +(cid:0) odd: + +Case (cid:12) + +(cid:0) , with (cid:12)(cid:5)(cid:2) + +(cid:0) even: + +(cid:8)(cid:5)(cid:9) + +(cid:8)(cid:5)(cid:9) + +(cid:12)(cid:7)(cid:6)(cid:18)(cid:1)(cid:19)(cid:14) + +sqr + +(cid:4) div (cid:0) + +(cid:4) div (cid:0) +(cid:4) div (cid:0) + +(cid:8)(cid:5)(cid:9) + +(cid:8)(cid:5)(cid:9) + +(cid:4) div (cid:0) + +(cid:4) div (cid:0) + +(cid:8)(cid:5)(cid:9) + +(cid:23) sqr * + +(cid:12)(cid:7)(cid:6)(cid:18)(cid:1)(cid:19)(cid:14) + +(cid:9)(cid:8) + +(cid:0) The function square is called 4 times, and power is called 8 + +Answer to 2.8: +times. A complete trace is: +power(1.037155,19) is 1.037155 * power(1.037155,18); +power(1.037155,18) is square( power(1.037155,9) ); +power(1.037155,9) is 1.037155 * power(1.037155,8); +power(1.037155,8) is square( power(1.037155,4) ); +power(1.037155,4) is square( power(1.037155,2) ); +power(1.037155,2) is square( power(1.037155,1) ); +power(1.037155,1) is 1.037155 * power(1.037155,0); +power(1.037155,0) is 1.0. + +Revision: 6.47 + +(cid:0) +(cid:2) +(cid:0) +(cid:12) +(cid:3) +(cid:3) +(cid:3) +(cid:5) +(cid:2) +(cid:6) +(cid:4) + +(cid:0) +(cid:12) +(cid:0) +(cid:1) +(cid:0) +(cid:10) +(cid:1) +(cid:2) +(cid:1) +(cid:0) +(cid:2) +(cid:0) +(cid:0) +(cid:23) +(cid:6) +(cid:16) +(cid:1) +* +(cid:0) +(cid:10) +(cid:2) +(cid:2) +(cid:0) +(cid:23) +(cid:10) +* +(cid:2) +(cid:0) +(cid:1) +(cid:1) +(cid:2) +(cid:0) +(cid:0) +(cid:5) +(cid:0) +(cid:1) +(cid:23) +(cid:6) +(cid:16) +(cid:1) +* +(cid:0) +(cid:0) +(cid:5) +(cid:10) +(cid:1) +(cid:8) +(cid:9) +(cid:2) +(cid:0) +(cid:23) +(cid:14) +(cid:2) +(cid:0) +(cid:3) +(cid:0) +(cid:3) +* +(cid:0) +(cid:10) +(cid:1) +(cid:1) +(cid:2) +(cid:2) +(cid:0) +(cid:23) +(cid:10) +* +(cid:2) +(cid:0) +(cid:1) +(cid:1) +(cid:2) +(cid:0) +(cid:1) +(cid:0) +(cid:0) +(cid:1) +(cid:1) +(cid:2) +(cid:8) +(cid:23) +(cid:6) +(cid:16) +(cid:1) +* +(cid:0) +(cid:0) +(cid:0) +(cid:1) +(cid:1) +(cid:2) +(cid:5) +(cid:0) +(cid:0) +(cid:1) +(cid:1) +(cid:2) +(cid:0) +(cid:10) +(cid:0) +(cid:1) +(cid:1) +(cid:2) +(cid:2) +(cid:0) +(cid:5) +(cid:10) +(cid:0) +(cid:1) +(cid:1) +(cid:2) +(cid:2) +(cid:0) +(cid:23) +(cid:14) +(cid:2) +(cid:0) +(cid:3) +(cid:0) +(cid:3) +* +(cid:0) +(cid:10) +(cid:1) +(cid:1) +(cid:2) +(cid:2) +(cid:0) +(cid:23) +(cid:10) +* + 324 + +AppendixA. Answerstoexercises + +Answer to 2.9: +the SML version of sum into the C version. + +(cid:0) Here is the table of correspondence for the transformation of + +schema: Functional + +: +(cid:1)(cid:3)(cid:2) : +(cid:1)(cid:1)(cid:0) : +: +(cid:1)(cid:7)(cid:6) : +(cid:8)(cid:10)(cid:2) : +(cid:0) : +: + +: +: +: + +C +sum +sum +int +int +int +int +double (*f)( int ) +int -> real +double +real +i +i +n +n +f +f +i > n +i > n +0.0 +0.0 +f i + sum (i+1) n f f( i ) + sum( i+1, n, f ) + +Answer to 2.10: +of a number by repeatedly summing a progression of odd numbers. + +(cid:0) Here is an SML function square which computes the square + +(* square : int -> real *) +fun square n += let + +fun int2odd i = real (2*i-1) + +in + +sum 1 n int2odd + +end ; + +Here is the corresponding C version of square with its auxiliary function +int2odd. + +double int2odd( int i ) { + +return 2*i-1 ; + +} + +double square( int n ) { + +return sum( 1, n, int2odd ) ; + +} + +Answer to 2.11: + +(cid:0) Here is the SML function nearly_pi: + +(* nearly_pi : int -> real *) +fun nearly_pi n + += let + +in + +fun positive i = 1.0/real (4*i-3) +fun negative i = 1.0/real (4*i-1) + +Revision: 6.47 + +(cid:0) +(cid:1) +(cid:5) +(cid:8) +(cid:8) +(cid:5) +(cid:12) +(cid:13) +(cid:14) + 4.0 * ( sum 1 n positive - + +sum 1 n negative) + +end ; + +The implementation of this function in C yields two auxiliary functions and the +nearly_pi function itself. + +325 + +double positive( int i ) { + +return 1.0/(4*i-3) ; + +} + +double negative( int i ) { + +return 1.0/(4*i-1) ; + +} + +double nearly_pi( int n ) { + +return 4.0 * ( sum( 1, n, positive) - + +sum( 1, n, negative) ) ; + +} + +Answer to 2.12: +The de(cid:2)nition of int2real is the same as that de(cid:2)ned for terminal. + +(cid:0) The C version of product and factorial are given below. + +double product( int i, int n, double (*f) ( int ) ) { + +if( i > n ) { + +return 1.0 ; + +} else { + +return f( i ) * product( i+1, n, f ) ; + +} + +} + +double factorial( int n ) { + +return product( 1, n, int2real ) ; + +} + +Answer to 2.13: +number (cid:0) : + +(cid:0) The function nearly_e calculates an approximation to the + +(* nearly_e : int -> real *) +fun nearly_e n += let + +fun f i = 1.0/factorial i + +in + +1.0 + sum 1 n f + +end ; + +Revision: 6.47 + + 326 + +AppendixA. Answerstoexercises + +The translation of this function into C yields an auxiliary function to compute the +reciprocal of the factorial and the nearly_e function itself: + +double recip_factorial( int i ) { + +return 1.0/factorial( i ) ; + +} + +double nearly_e( int n ) { + +return 1.0 + sum( 1, n, recip_factorial ) ; + +} + +Answer to 2.14: + +(cid:0) Here is product rede(cid:2)ned in terms of repeat: + +(* product : int -> int -> (int -> real) -> real *) +fun product i n f + += let + +in + +fun multiply x y = x * y + +repeat 1.0 multiply i n f + +end ; + +Answer to 2.15: Here is a monomorphic C version of repeat, which is suitable +for use in sum and product. + +double repeat( double base, + +double (*combine) (double, double), +int i, int n, double (*f) (int) ) { + +if( i > n ) { + +return base ; + +} else { + +return combine( f( i ), + +} + +} + +repeat( base, combine, i+1, n, f) ) ; + +Here is the rede(cid:2)ned sum in terms of repeat. It requires an auxiliary function +double_add: + +double double_add( double x, double y ) { + +return x+y ; + +} + +double sum( int i, int n, double (*f) (int) ) { +return repeat( 0.0, double_add, i, n, f ) ; + +} + +Revision: 6.47 + + Answer to 2.16: Here is the SML function nearly_phi to calculate an approxi- +mation of the golden ratio: + +327 + +(* nearly_phi : int -> real *) +fun nearly_phi n + += let + +in + +fun constant_one i = 1.0 +fun divide x y = x / (1.0 + y) + +1.0 + repeat 1.0 divide 1 n constant_one + +end ; + +The C version of nearly_phi requires two auxiliary functions: + +double constant_one( int i ) { + +return 1.0 ; + +} + +double divide( double x, double y ) { + +return x / (1.0 + y) ; + +} + +double nearly_phi( int n ) { + +return 1.0 + repeat( 1.0, divide, 1, n, constant_one ) ; + +} + +Answer to 2.17: The general SML function schema for a cascade of (cid:0) conditionals +with (cid:0) +(*SML general function schema with locals*) + +local de(cid:2)nitions is: + +(* (cid:0) : (cid:1)(cid:3)(cid:2) -> ... (cid:1)(cid:5)(cid:4) -> (cid:1)(cid:7)(cid:6) *) +fun (cid:0)(cid:9)(cid:8)(cid:10)(cid:2) ... (cid:8)(cid:11)(cid:4) += let + +(cid:2) = + +(cid:2) (* (cid:2) + +(cid:2) : (cid:1) + +*) + +(cid:2)(cid:1) = + +(cid:1) (* (cid:2) + +(cid:3)(cid:1) : (cid:1) + +(cid:0)(cid:5)(cid:4) *) + +val (cid:2) +... +val (cid:2) + +if (cid:12) + +in + +then (cid:13) +else if (cid:12) + +then (cid:13) + +end ; + +... +else if (cid:12) + +then (cid:13) +else (cid:14) + +Revision: 6.47 + +(cid:5) +(cid:0) +(cid:6) +(cid:5) +(cid:2) +(cid:2) +(cid:0) +(cid:0) +(cid:1) +(cid:1) + 328 + +AppendixA. Answerstoexercises + +The (cid:8)(cid:10)(cid:2)(cid:10)(cid:16)(cid:21)(cid:16)(cid:18)(cid:16)(cid:3)(cid:8)(cid:20)(cid:4) are the arguments of (cid:0) +type of the function result is (cid:1)(cid:22)(cid:6) . The local variables of (cid:0) are (cid:2) +the expressions + +, and their types are (cid:1)(cid:21)(cid:2)(cid:23)(cid:16)(cid:21)(cid:16)(cid:18)(cid:16)(cid:22)(cid:1)(cid:7)(cid:4) respectively. The +(cid:2)(cid:1) ; their values are +(cid:0)(cid:5)(cid:4) respectively. The expressions +and +(cid:14) are expressions over the local variables and arguments. The corresponding gen- +eral C function schema is: +/*C general function schema with locals*/ + +are predicates over the arguments and the local variables. The (cid:13) + +(cid:1) and their types are (cid:1) + +. . . (cid:1) + +(cid:2)(cid:10)(cid:16)(cid:21)(cid:16)(cid:18)(cid:16)(cid:5)(cid:13) + +(cid:2)(cid:17)(cid:16)(cid:18)(cid:16)(cid:18)(cid:16) + +(cid:2)(cid:17)(cid:16)(cid:18)(cid:16)(cid:18)(cid:16) + +(cid:2)(cid:17)(cid:16)(cid:18)(cid:16)(cid:21)(cid:16) + +(cid:1)(cid:7)(cid:6) + +(cid:8)(cid:10)(cid:2) , ... (cid:1)(cid:5)(cid:4) + +(cid:8)(cid:20)(cid:4) ) { + +(cid:0) ( (cid:1)(cid:3)(cid:2) +const (cid:1) +... +const (cid:1) +if ( (cid:12) + +(cid:2) = + +(cid:2) ; + +(cid:3)(cid:1) = + +(cid:1) ; + +(cid:2) ) { + +(cid:2) ; +return (cid:13) +} else if ( (cid:12) +return (cid:13) +(cid:0) ; +... + +} else if ( (cid:12) +; +return (cid:13) + +} else { + +return (cid:14) ; + +(cid:0) ) { + +) { + +} + +} + +Answer to 2.20: +Fahrenheit is: + +The relation between a temperature in Centigrade and + +&(cid:10) + +fahrenheit + +fahrenheit + +The SML function reads: + +(* fahrenheit : real -> real *) +fun fahrenheit c = c * 9.0 / 5.0 + 32.0 ; + +The corresponding C program is: + +#include + +double fahrenheit( double c ) { +return c * 9.0 / 5.0 + 32.0 ; + +} + +int main( void ) { + +printf( "Fahrenheit\n") ; +printf( "%f\n", fahrenheit( 0 ) ) ; + +Revision: 6.47 + +(cid:2) +(cid:5) +(cid:5) +(cid:0) +(cid:6) +(cid:12) +(cid:12) +(cid:1) +(cid:1) +(cid:0) +(cid:6) +(cid:2) +(cid:5) +(cid:0) +(cid:4) +(cid:2) +(cid:5) +(cid:1) +(cid:1) +(cid:0) +(cid:3) +(cid:0) +(cid:2) +(cid:6) +(cid:0) +(cid:2) +(cid:6) +(cid:2) +(cid:6) +(cid:1) +(cid:3) +(cid:8) +(cid:0) +(cid:3) +(cid:5) +(cid:2) +(cid:9) +(cid:2) +(cid:2) +(cid:6) + 329 + +printf( "%f\n", fahrenheit( 28 ) ) ; +printf( "%f\n", fahrenheit( 37 ) ) ; +printf( "%f\n", fahrenheit( 100 ) ) ; +return 0 ; + +} + +This will print the following output: + +32.000000 +82.400000 +98.600000 +212.000000 + +Answer to 2.21: + +(a) The speci(cid:2)cation of the pop_count function is: + +pop_count + +(cid:2)(cid:17)(cid:16)(cid:18)(cid:16)(cid:18)(cid:16) + +(b) Here is an SML function that implements the population count instruction: + +(* pop_count : int -> int *) +fun pop_count n + += if n = 0 + +then 0 : int +else n mod 2 + pop_count (n div 2) ; + +(c) Here is the C version of pop_count: + +int pop_count( int n ) { + +if( n == 0 ) { +return 0 ; + +} else { + +return n % 2 + pop_count (n / 2) ; + +} + +} + +(d) The table of correspondence for the function schema is: + +(cid:1)(cid:3)(cid:2) + +(cid:1)(cid:7)(cid:6) + +(cid:8)(cid:10)(cid:2) + +Schema Functional + +pop_count +int +int +n +n = 0 +0 +n mod 2 + +pop_count (n div 2) pop_count (n / 2) + +C +pop_count +int +int +n +n == 0 +0 +n % 2 + + +Revision: 6.47 + +(cid:0) +(cid:1) +(cid:1) +(cid:4) +(cid:1) +(cid:4) +(cid:10) +(cid:1) +(cid:2) +(cid:1) +(cid:1) +(cid:8) +(cid:0) +(cid:4) +(cid:0) +(cid:8) +(cid:9) +(cid:1) +(cid:1) +(cid:8) +(cid:0) +(cid:12) +(cid:0) +(cid:13) + 330 + +AppendixA. Answerstoexercises + +(e) Here is a main program that calls pop_count: + +#include + +/*C population count*/ + +int main( void ) { + +printf( "population count\n") ; +printf( "of +printf( "of +printf( "of 65535 is %d\n", pop_count( 65535 ) ) ; +return 0 ; + +0 is %d\n", pop_count( 0 ) ) ; +9 is %d\n", pop_count( 9 ) ) ; + +} + +The solution to the population count problem could be formulated better using +the bit-operators of C. The >> operator shifts an integer to the right, and the & +operator performs an and-operation on the integer. Thus pop_count could be +written as: + +int pop_count( int n ) { + +if( n == 0 ) { +return 0 ; + +} else { + +return (n & 1) + pop_count( n >> 1 ) ; + +} + +} + +Note that because the & operator has a lower priority than the + operator, the ex- +pression n&1 needs to be in parentheses. Without the parentheses, the return value +would be n & (1 + pop_count(n>>1) ), which is different. + +Answer to 2.22: + +(a) The speci(cid:2)cation of the checksum function is: + +(cid:1)1(cid:15) + +checksum + +(cid:16)(cid:18)(cid:16)(cid:18)(cid:16) + +(cid:8)(cid:5)(cid:9) + +(b) Here is an SML function that implements the checksum function: + +(* checksum : int -> int *) +fun checksum n += if n = 0 + +then 0 : int +else n mod 16 + checksum (n div 16) ; + +Here are some test cases for checksum: + +checksum 0 ; +checksum 17 ; +checksum 18 ; +checksum 65535 ; + +Revision: 6.47 + +(cid:0) +(cid:1) +(cid:15) +(cid:1) +(cid:10) +(cid:2) +(cid:15) +(cid:2) +(cid:15) +(cid:1) +(cid:8) +(cid:0) +(cid:1) +(cid:0) +(cid:1) +(cid:15) +(cid:8) + 331 + +(c) Here is the C version of checksum: + +int checksum( int n ) { + +if( n == 0 ) { +return 0 ; + +} else { + +return n % 16 + checksum(n / 16) ; + +} + +} + +(d) The table of correspondence for the function schema is: + +Schema Functional +checksum +int +int +n +n = 0 +0 +n mod 16 + +checksum(n div 16) checksum(n / 16) + +C +checksum +int +int +n +n == 0 +0 +n % 16 + + +(e) Here is a main program that calls checksum: + +int main( void ) { + +printf( "nibble checksum\n") ; +printf( "of +printf( "of +printf( "of +printf( "of 65535 is %d\n", checksum( 65535 ) ) ; +return 0 ; + +0 is %d\n", checksum( 0 ) ) ; +17 is %d\n", checksum( 17 ) ) ; +18 is %d\n", checksum( 18 ) ) ; + +} + +Answer to 2.23: +number: + +(cid:0) Here is an SML function that computes the + +-th Fibonacci + +(* fib : int -> int *) +fun fib n + += if n = 0 + +then 0 : int +else if n = 1 + +then 1 +else fib (n-1) + fib (n-2) ; + +Here is the C version of fib embedded in a main program: + +#include + +int fib ( int n ) { +if( n == 0 ) { + +Revision: 6.47 + +(cid:0) +(cid:1) +(cid:2) +(cid:1) +(cid:6) +(cid:8) +(cid:2) +(cid:12) +(cid:0) +(cid:13) +(cid:15) + 332 + +AppendixA. Answerstoexercises + +return 0 ; + +} else if( n == 1 ) { + +return 1 ; + +} else { + +return fib( n-1 ) + fib( n-2 ) ; + +} + +} + +int main( void ) { + +printf( "Fibonacci\n") ; +printf( "0 %d\n", fib( 0 ) ) ; +printf( "1 %d\n", fib( 1 ) ) ; +printf( "7 %d\n", fib( 7 ) ) ; +return 0 ; + +} + +Answer to 2.24: + +(a) The differences between the Fibonacci series and the nFib series are: + +(cid:1) The Fibonacci series starts with 0, the nFib series with 1; + +(cid:1) The nFib series adds an extra 1 for each application of the inductive + +case. + +(b) Here is an SML function that computes the + +-th nFib number: + +(* nfib : int -> int *) +fun nfib n = if n = 0 orelse n = 1 + +then 1 : int +else 1 + nfib(n-1) + nfib(n-2) ; + +Here are a few test cases for nfib: + +nfib 0 ; +nfib 1 ; +nfib 7 ; + +(c) Here is the C version of nfib: + +int nfib( int n ) { + +if( n == 0 || n == 1 ) { + +return 1 ; + +} else { + +return 1 + nfib( n-1 ) + nfib( n-2 ) ; + +} + +} + +(d) Here is a main program for testing the C version of nfib: + +int main( void ) { + +printf( "nFib\n") ; + +Revision: 6.47 + +(cid:0) +(cid:15) + 333 + +printf( "of 0 is %d\n", nfib( 0 ) ) ; +printf( "of 1 is %d\n", nfib( 1 ) ) ; +printf( "of 7 is %d\n", nfib( 7 ) ) ; +return 0 ; + +} + +Answer to 2.25: + +(cid:0) Here is an SML function that computes powers of powers: + +(* power_of_power : int -> int -> int *) +fun power_of_power m n + += if n = 0 + +then 1 +else power m (power_of_power m (n-1)) ; + +It uses a straightforward integer power function: + +(* power : int -> int -> int *) +fun power r p = if p = 0 + +then 1 : int +else r * power r (p-1) ; + +Here is the C version of power_of_power embedded in a main program: + +#include + +int power( int r, int p ) { + +if( p == 0 ) { +return 1 ; + +} else { + +return r * power( r, p-1 ) ; + +} + +} + +int power_of_power( int m, int n ) { + +if( n == 0 ) { +return 1 ; + +} else { + +return power( m, power_of_power( m, n-1 ) ) ; + +} + +} + +int main( void ) { + +printf( "power of power\n") ; +printf( "0 17: %d\n", power_of_power( 0, 17 ) ) ; +printf( "1 17: %d\n", power_of_power( 1, 17 ) ) ; +printf( "2 0: %d\n", power_of_power( 2, 0 ) ) ; +printf( "2 1: %d\n", power_of_power( 2, 1 ) ) ; +printf( "2 2: %d\n", power_of_power( 2, 2 ) ) ; +printf( "2 3: %d\n", power_of_power( 2, 3 ) ) ; + +Revision: 6.47 + + AppendixA. Answerstoexercises + +printf( "2 4: %d\n", power_of_power( 2, 4 ) ) ; +return 0 ; + +334 + +} + +Answer to 2.26: + +(a) Given the function (cid:0) + +(cid:1) , +here is how the Newton-Raphson method calculates an approximation to the +root: + +, and an initial approximation (cid:8) + +, its derivative (cid:0) + +newton raphson + +&(cid:10) + +newton raphson + +newton raphson + +otherwise + +(cid:0)(cid:12)(cid:11) + +if + +(cid:8)(cid:16)(cid:14) + +is further from 0 than the (small) distance (cid:5) allows, a subsequent ap- +If (cid:0) +proximation is made. By choosing a small enough value for (cid:5) , the root will +be determined with a high precision, but for a value of (cid:5) which is too small +the algorithm might not (cid:2)nd a root. + +(b) For convenience, + +parametrised over (cid:5) , (cid:0) + +the SML version of the Newton-Raphson method is +(cid:11) so that the distance (cid:5) and the functions (cid:0) and +(cid:11) are passed to the function calculating the root. This gives the following + +, and (cid:0) + +function: + +(* newton_raphson : (real->real) -> (real->real) -> + +fun newton_raphson f f(cid:146) eps x + += let + +real -> real *) + +val fx = f(x) (* fx : real *) + +in + +if absolute(fx) < eps + +then x +else newton_raphson f f(cid:146) eps (x-fx/f(cid:146)(x)) + +end ; + +(c) Here is the de(cid:2)nition of parabola and its derivative parabola(cid:146) + +: + +(* parabola : real -> real *) +fun parabola x = x * x - 2.0 ; + +(* parabola(cid:146) : real -> real *) +fun parabola(cid:146) x = 2.0 * x ; + +The following table gives the results of using the Newton-Raphson method +to (cid:2)nd the root of the parabola function for a number of values for the ini- +tial estimate and the accuracy. + +newton_raphson parabola parabola(cid:146) 0.001 1.5 = 1.41421; +newton_raphson parabola parabola(cid:146) 0.1 200.0 = 1.41624; + +Revision: 6.47 + +(cid:1) +(cid:8) +(cid:8) +(cid:11) +(cid:1) +(cid:8) +(cid:8) +(cid:14) +(cid:0) +(cid:14) +(cid:0) +(cid:11) +(cid:0) +(cid:2) +(cid:6) +(cid:2) +(cid:6) +(cid:1) +(cid:8) +(cid:8) +(cid:0) +(cid:6) +(cid:7) +(cid:8) +(cid:7) +(cid:9) +(cid:8) +(cid:14) +(cid:29) +(cid:0) +(cid:1) +(cid:8) +(cid:8) +(cid:29) +(cid:10) +(cid:5) +(cid:1) +(cid:8) +(cid:0) +(cid:0) +(cid:1) +(cid:8) +(cid:8) +(cid:1) +(cid:8) +(cid:8) +(cid:1) +(cid:8) +(cid:8) +(cid:0) + As expected the second answer is not as precise as the (cid:2)rst ( (cid:0) + +(cid:16)(cid:18)(cid:16)(cid:18)(cid:16) ). + +(cid:9)(cid:5)(cid:4) + +(d) The C implementation of the Newton Raphson program is shown below. + +335 + +#include + +double absolute( double x ) { + +if( x >= 0 ) { +return x ; + +} else { + +return -x ; + +} + +} + +double newton_raphson( double (*f)( double ), + +double (*f_)( double ), +double eps, double x ) { + +const double fx = f( x ) ; +if( absolute( fx ) < eps ) { + +return x ; + +} else { + +return newton_raphson( f, f_, eps, x - fx/f_(x) ) ; + +} + +} + +double parabola( double x ) { + +return x * x - 2.0 ; + +} + +double parabola_( double x ) { + +return 2 * x ; + +} + +int main( void ) { + +printf( "%f\n", newton_raphson( parabola, parabola_, + +printf( "%f\n", newton_raphson( parabola, parabola_, + +0.001, 1.5 ) ) ; + +0.1, 200.0 ) ) ; + +return 0 ; + +} + +The second argument to newton_raphson represents the derivative of the +function f. C does not permit the use of an apostrophe ((cid:146) ) in an identi(cid:2)er, so +we had to choose another character (_) instead. + +(e) The execution of the C program will as always start by executing the +(cid:2)rst statement of main, a call to printf, which requires the value of +newton_raphson(...) to be calculated. This function is invoked with + +Revision: 6.47 + +(cid:6) +(cid:0) +(cid:0) +(cid:16) +(cid:1) +(cid:0) +(cid:1) +(cid:6) +(cid:2) + 336 + +AppendixA. Answerstoexercises + +four arguments; the arguments eps and x have the values 0.001 and 1.5, +while the arguments f and f_ have the values parabola and parabola_. +The (cid:2)rst statement of newton_raphson is + +const double fx = f( x ) ; + +Because the argument f in this case is the function parabola, and x has the +value 1.5, this is effectively the same as: + +const double fx = parabola( 1.5 ) ; + +the double fx has the value +This results in the value 0.25. Hence, +0.25. Because the absolute value of 0.25 is greater than eps, the function +newton_raphson is recursively called with the same arguments as before, +except x, which is now: + +x-fx/f_(x) (cid:0) 1.5 - 0.25/parabola_( 1.5 ) + +This evaluates to about 1.41667. Then the next iteration starts by com- +puting fx = f( x ), which is about 0.006944444. This is just larger +than eps, so a third call to newton_raphson is performed with x equal to +1.4142156862. . . which is correct to the (cid:2)rst 5 digits. +(f) The Newton Raphson method does not terminate for (cid:0) + +starting with (cid:8) + +. The (cid:2)rst new point is (cid:8)(cid:24)(cid:2) + +(cid:0)(cid:2)(cid:1) + +(cid:0) when +, the next point + +is (cid:8) +the function. + +(cid:9) . Each next point is further away from the root of + +Revision: 6.47 + +(cid:1) +(cid:8) +(cid:8) +(cid:0) +(cid:2) +(cid:0) +(cid:0) +(cid:1) +(cid:0) +(cid:2) +(cid:0) +(cid:2) +(cid:0) +(cid:0) +(cid:0) +(cid:5) +(cid:4) +(cid:0) +(cid:5) +(cid:4) +(cid:0) +(cid:0) +(cid:2) +(cid:0) +(cid:0) +(cid:0) +(cid:2) +(cid:0) +(cid:0) +(cid:0) +(cid:10) +(cid:5) +(cid:4) +(cid:0) +(cid:1) +(cid:0) +(cid:10) +(cid:5) +(cid:4) +(cid:0) +(cid:0) +(cid:0) + 337 + +Answers to the exercises of Chapter 3 + +Answer to 3.2: The SML and C versions of leap that take the extended range of +years into account are: + +(* leap : int -> int *) +fun leap y = if y mod 4 <> 0 orelse + +y mod 100 = 0 andalso y mod 400 <> 0 +then leap (y+1) +else y ; + +int leap( int y ) { + +if( (y % 4 != 0) || + +(y % 100 == 0 && y % 400 != 0) ) { + +return leap( y+1 ) ; + +} else { + +return y ; + +} + +} + +Answer to 3.3: +versions of leap. The (cid:2)rst column refers to the basic while-schema. + +(cid:0) The table below shows the correspondence between the two + +schema: Functional + +C +leap +int +int +y + +leap +int +int +y +y mod 4 <> 0 y % 4 != 0 +y+1 +y + +y+1 +y + +: +(cid:1) : +(cid:1)(cid:7)(cid:6) : +: +: +: +: + +Answer to 3.5: +ment while-schema and the version of euclid above is as follows: + +(cid:0) The correspondence between elements of the multiple argu- + +Revision: 6.41 + +(cid:0) +(cid:8) +(cid:12) +(cid:13) +(cid:14) + 338 + +AppendixA. Answerstoexercises + +: +: + +schema: + +Functional +euclid +2 +(int*int) +int +(cid:0) ): (m,n) +n > 0 +(n,m mod n) (n,m % n) +m + +C +euclid +2 +(int,int) +int +(m,n) +n > 0 + +m + +( (cid:1)(cid:3)(cid:2) * (cid:1)(cid:1)(cid:0) ): +(cid:1)(cid:7)(cid:6) : +( (cid:8)(cid:10)(cid:2) , (cid:8) +: +: +: + +Answer to 3.6: + +Just after executing +the code +int euclid( int m, int n ) { 9 +while( n > 0 ) { +9 +const int old_n = n ; +9 +n = m % old_n ; +9 +m = old_n ; +6 +while( n > 0 ) { +6 +const int old_n = n ; +6 +n = m % old_n ; +6 +m = old_n ; +3 +while( n > 0 ) { +3 +return m ; +3 + +values of +m n old_n + +6 +6 +6 +3 +3 +3 +3 +0 +0 +0 +0 + +6 +6 +6 + +3 +3 +3 + +The function returns the value 3. + +Answer to 3.7: + +(cid:0) Proof of the hypothesis n (cid:1) + +(cid:0) fac n by induction over n: + +Case 1: +1 (cid:1) + +Case n+1: +(n+1) (cid:1) + +(cid:8)(cid:5)(cid:9) + +(cid:2) i + +1 +fac 1 + +(cid:23) fac.1 * + +(cid:8)(cid:5)(cid:9) + +(cid:8)(cid:5)(cid:9) + +(cid:2) i (cid:23) + +(cid:2) i +(n+1) * (cid:10) +(n+1) * n (cid:1) +(n+1) * fac n (cid:23) hypothesis * +fac (n+1) + +(cid:23) fac.1 * + +(cid:9)(cid:8) + +Revision: 6.41 + +(cid:0) +(cid:15) +(cid:12) +(cid:13) +(cid:14) +(cid:0) +(cid:10) +(cid:2) +(cid:23) +(cid:1) +* +(cid:0) +(cid:23) +(cid:10) +* +(cid:0) +(cid:0) +(cid:10) +(cid:4) +(cid:1) +(cid:2) +(cid:23) +(cid:1) +* +(cid:0) +(cid:4) +(cid:10) +* +(cid:0) +(cid:23) +(cid:1) +* +(cid:0) +(cid:0) + Answer to 3.8: Proof of the hypothesis b * n (cid:1) +over n: + +(cid:0) fac_accu n b by induction + +339 + +Case 1: +b * 1 (cid:1) + +Case n+1: +b * (n+1) (cid:1) + +b * 1 +b +fac_accu 1 b + +(cid:23) arithmetic * +(cid:23) fac_accu * + +b * (n+1) * n (cid:1) +(b * (n+1)) * n (cid:1) +fac_accu n (b * (n+1)) (cid:23) hypothesis * +fac_accu n ((n+1) * b) (cid:23) commutativity* * +fac_accu (n+1) b + +(cid:23) associativity* * + +(cid:23) fac_accu * + +(cid:9)(cid:8) + +Answer to 3.9: +fac_accu and the schema (after tupling): + +(cid:0) The correspondence between the elements of the function + +schema: + +: +: + +( (cid:1)(cid:3)(cid:2) * (cid:1)(cid:1)(cid:0) ): +( (cid:8)(cid:10)(cid:2) * (cid:8) +: +: +: + +Functional +fac_accu +2 +(int*int) (int,int) + +C +fac_accu +2 + +(cid:0) ): (n,b) +n > 1 +(n-1,n*b) (n-1,n*b) +b + +(n,b) +n > 1 + +b + +Answer to 3.10: An ef(cid:2)cient body of the while statement would be as shown be- +low. It is not elegant, as the statements that compute the values of m and f_m ap- +pear in two places. This makes the code dif(cid:2)cult to maintain, since it means that a +change of the code has to be made twice. + +if( f_m < 0.0 ) { + +l = m ; + +} else { + +h = m ; + +} +m = (l+h)/2.0 ; +f_m = f(m) ; + +Answer to 3.11: The problem is that, before terminating, main wants to perform +an operation on the value returned by bisection. A naive inlining operation would + +Revision: 6.41 + +(cid:0) +(cid:23) +(cid:1) +* +(cid:0) +(cid:0) +(cid:0) +(cid:23) +(cid:1) +* +(cid:0) +(cid:0) +(cid:0) +(cid:0) +(cid:0) +(cid:15) +(cid:12) +(cid:13) +(cid:14) + 340 + +AppendixA. Answerstoexercises + +duplicate this operation. The solution is to break out of the while loop using a +break, as shown below: + +int main( void ) { + +double x ; +double l = 0.0 ; +double h = 2.0 ; +double m ; +double f_m ; +while( true ) { + +m = (l+h)/2.0 ; +f_m = parabola(m) ; +if( absolute( f_m ) < eps ) { + +x = m ; +break ; + +} else if( absolute( h-l ) < delta ) { + +x = m ; +break ; + +} else if( f_m < 0.0 ) { + +l = m ; + +} else { + +h = m ; + +} + +} +printf("The answer is %f\n", x ) ; +return 0 ; + +} + +Note that this program can be optimised: x merely serves to bring the value of m +out of the while-loop. If every instance of m is replaced by x, the program will be a +bit shorter. + +Answer to 3.12: The relationship between repeat on the one hand and the func- +tions from this chapter on the other hand is: + +repeat (cid:1) + +(cid:0) foldr (cid:3) + +(cid:1) (map (cid:0) ( (cid:0) -- + +)) + +This shows that repeat combines the generation of a sequence of values with the +accumulation of the result. +In the approach that we have taken in this chapter, +these two activities are separated. This increases the (cid:3)exibility and the usefulness +of the individual building blocks foldr, map and --. + +Revision: 6.41 + +(cid:3) +(cid:0) +(cid:15) +(cid:0) +(cid:15) + Answer to 3.13: + +(cid:0) Proof of (3.4) by induction on the length of the list (cid:8) + +(cid:3) . + +341 + +Case []: +foldl (cid:13) + +(cid:1) (map (cid:0) []) + +foldl (cid:13) + +(cid:1) [] + +foldl (cid:14) + +(cid:1) [] + +Case ( (cid:8) :: (cid:8) +foldl (cid:13) + +(cid:3) ): + +(cid:1) (map (cid:0) ( (cid:8) :: (cid:8) +(cid:1) ( (cid:0) + +(cid:3) )) + +(cid:8) ::map (cid:0) + +(cid:8) ) + +foldl (cid:13) +foldl (cid:13) ((cid:13) +foldl (cid:14) ( (cid:13) +foldl (cid:14) ( (cid:14) +foldl (cid:14) + +(cid:8) ) (cid:8) +(cid:3) ) + +(cid:1) ( (cid:8) : (cid:8) + +(cid:1) ( (cid:0) +(cid:1) ( (cid:0) + +(cid:8) )) (map (cid:0)(cid:9)(cid:8) +(cid:8) )) (cid:8) + +(cid:23) map.1 * +(cid:23) foldl.1 * +(cid:23) foldl.1 * + +(cid:23) map.2 * +(cid:3) ) (cid:23) foldl.2 * + +(cid:23) hypothesis * +(cid:14) .1 * +(cid:23) foldl.2 * + +(cid:9)(cid:8) + +Revision: 6.41 + +(cid:0) +(cid:0) +(cid:1) +(cid:0) +(cid:0) +(cid:0) +(cid:0) +(cid:3) +(cid:0) +(cid:1) +(cid:3) +(cid:23) +(cid:0) + 342 + +AppendixA. Answerstoexercises + +Answer to 3.14: Proof of (3.6) by induction on the length of the list (cid:8) + +(cid:3) . + +Case []: +foldl (cid:13) + +(cid:1) (filter (cid:12) []) +(cid:1) [] + +foldl (cid:13) + +foldl (cid:14) + +(cid:1) [] + +Case ( (cid:8) : (cid:8) +foldl (cid:13) + +(cid:8) = false: + +(cid:3) ) and (cid:12) +(cid:1) (filter (cid:12) ( (cid:8) :: (cid:8) +(cid:1) (if (cid:12) + +foldl (cid:13) + +(cid:3) )) + +then (cid:8) ::filter (cid:12) +else filter (cid:12) + +(cid:3) ) + +(cid:1) (filter (cid:12) + +foldl (cid:13) +foldl (cid:14) +foldl (cid:14) (if (cid:12) + +(cid:3) ) + +then (cid:13) +else (cid:1) ) (cid:8) +(cid:8) ) (cid:8) +(cid:3) ) + +foldl (cid:14) ( (cid:14) +foldl (cid:14) + +(cid:1) ( (cid:8) : (cid:8) + +Case ( (cid:8) : (cid:8) +foldl (cid:13) + +(cid:3) ) and (cid:12) +(cid:8) = true: +(cid:1) (filter (cid:12) ( (cid:8) :: (cid:8) +(cid:1) (if (cid:12) + +foldl (cid:13) + +(cid:3) )) + +then (cid:8) ::filter (cid:12) +else filter (cid:12) + +(cid:3) ) + +foldl (cid:13) +foldl (cid:13) ((cid:13) +foldl (cid:14) ((cid:13) +foldl (cid:14) (if (cid:12) + +(cid:1) ( (cid:8) ::filter (cid:12) + +(cid:8) ) + +(cid:8) ) (filter (cid:12) +(cid:8) ) (cid:8) + +(cid:3) ) + +then (cid:13) +else (cid:1) ) (cid:8) +(cid:8) ) (cid:8) +(cid:3) ) + +foldl (cid:14) ( (cid:14) +foldl (cid:14) + +(cid:1) ( (cid:8) : (cid:8) + +(cid:23) filter.1 * +(cid:23) foldl.1 * +(cid:23) foldl.1 * + +(cid:23) filter.2 * + +(cid:8) = false * + +(cid:23) hypothesis * + +(cid:8) = false * + +(cid:14) .1 * +(cid:23) foldl.2 * + +(cid:23) filter.2 * + +(cid:8) = true * + +(cid:23) foldl.2 * +(cid:23) hypothesis * + +(cid:8) = true * + +(cid:14) .1 * +(cid:23) foldl.2 * + +(cid:9)(cid:8) + +Answer to 3.16: The looping C version (using bit operation) reads: + +int pop_count( int n ) { + +int accu = 0 ; +while( n != 0 ) { + +accu = accu + (n&1) ; +n = n >> 1 ; + +} +return accu ; + +} + +Revision: 6.41 + +(cid:0) +(cid:0) +(cid:1) +(cid:0) +(cid:0) +(cid:8) +(cid:8) +(cid:3) +(cid:8) +(cid:0) +(cid:8) +(cid:23) +(cid:12) +(cid:0) +(cid:1) +(cid:8) +(cid:3) +(cid:0) +(cid:8) +(cid:1) +(cid:8) +(cid:3) +(cid:23) +(cid:12) +(cid:0) +(cid:1) +(cid:3) +(cid:23) +(cid:0) +(cid:0) +(cid:8) +(cid:8) +(cid:3) +(cid:8) +(cid:0) +(cid:23) +(cid:12) +(cid:0) +(cid:1) +(cid:8) +(cid:0) +(cid:1) +(cid:3) +(cid:0) +(cid:8) +(cid:1) +(cid:8) +(cid:3) +(cid:23) +(cid:12) +(cid:0) +(cid:1) +(cid:3) +(cid:23) +(cid:0) + 343 + +int main( void ) { + +printf( "population count\n"); +printf( "of +printf( "of +printf( "of 65535 is %d\n", pop_count( 65535 ) ) ; +return 0 ; + +0 is %d\n", pop_count( 0 ) ) ; +9 is %d\n", pop_count( 9 ) ) ; + +} + +Answer to 3.17: Here is the C version of power_of_power embedded in a main +program: + +#include + +int power( int r, int p ) { + +int accu = 1 ; +while( p != 0 ) { + +accu = accu * r ; +p = p - 1 ; + +} +return accu ; + +} + +int power_of_power( int m, int n ) { + +int accu = 1 ; +while( n != 0 ) { + +accu = power( m, accu ) ; +n = n - 1 ; + +} +return accu ; + +} + +int main( void ) { + +printf( "power of power\n"); +printf( "0 17: %d\n", power_of_power( 0, 17 ) ) ; +printf( "1 17: %d\n", power_of_power( 1, 17 ) ) ; +printf( "2 0: %d\n", power_of_power( 2, 0 ) ) ; +printf( "2 1: %d\n", power_of_power( 2, 1 ) ) ; +printf( "2 2: %d\n", power_of_power( 2, 2 ) ) ; +printf( "2 3: %d\n", power_of_power( 2, 3 ) ) ; +printf( "2 4: %d\n", power_of_power( 2, 4 ) ) ; +return 0 ; + +} + +Inlining power into power_of_power is not really desirable in this case. The +function becomes messy, and a function power is a useful building block anyway. +A (cid:2)rst result would be: + +Revision: 6.41 + + 344 + +AppendixA. Answerstoexercises + +int power_of_power( int m, int n ) { + +int accu = 1 ; +while( n != 0 ) { +int p = accu ; +int power = 1 ; +while( p != 0 ) { + +power = power * m ; +p = p - 1 ; + +} +accu = power ; +n = n - 1 ; + +} +return accu ; + +} + +Note that one of the variables p or power is, strictly speaking, super(cid:3)uous: replac- +ing all occurrences of p with accu would not modify the functionality of the pro- +gram. Replacing all occurrences of power with accu would also be legal. How- +ever, you cannot remove both p and power. + +Answer to 3.18: +functions: + +(cid:0) Here is the C function chess_board and three auxiliary + +bool odd( int i ) { + +return i % 2 == 1 ; + +} + +void dash( int width ) { + +int col ; +for( col = 1; col <= width; col++ ) { + +printf( "--" ) ; + +} +printf( "-\n" ) ; + +} + +void black_or_white( int row, int width ) { + +int col ; +for( col = 1; col <= width; col++ ) { + +if( odd( row+col ) ) { + +printf( "|X" ) ; + +} else { + +printf( "| " ) ; + +} + +} +printf( "|\n" ) ; + +} + +Revision: 6.41 + + 345 + +void chess_board( int width, int height ) { + +int row ; +for( row = 1; row <= height; row ++ ) { + +dash( width ) ; +black_or_white( row, width ) ; + +} +dash( width ) ; + +} + +Answer to 3.19: + +(cid:0) The SML version with tupled arguments reads: + +(* newton_raphson : + +(real->real)*(real->real)*real*real -> real *) + +fun newton_raphson(f,f(cid:146),eps,b) + += let + +in + +val fb = f(b) + +if absolute fb < eps + +then b +else newton_raphson(f,f(cid:146),eps,b-fb /f(cid:146)(b)) + +end ; + +This neatly matches with the general tail recursion/while-schema. From the cor- +respondence for the schema, it follows that the multiple assignment statement for +the newton_raphson function should be: + +(f,f_,eps,b) = (f,f_,eps,b - f(b)/f_(b)) ; + +Only the value of b changes from one iteration of the while-loop to the next; the +other three arguments f, f_, and eps remain unchanged. Therefore, the multiple +assignment reduces to a single assignment-statement: b = b - f(b)/f_(b);. +The C implementation of the newton_raphson function is therefore: + +double newton_raphson( double (*f)( double ), + +double (*f_)( double ), +double eps, double b ) { + +double fb ; +while( true ) { +fb = f(b) ; +if( absolute( f(b) ) < eps ) { + +return b ; + +} else { + +b = b - fb / f_(b) ; + +} + +} + +} + +There is another C program with the same solution, using an assignment within +an expression. This solution is often quoted as truly idiomatic C: + +Revision: 6.41 + + 346 + +AppendixA. Answerstoexercises + +double newton_raphson( double (*f)( double ), + +double (*f_)( double ), +double eps, double b ) { + +double fb ; +while( absolute( fb = f(b) ) >= eps ) { + +b = b - fb/f_(b) ; + +} +return b ; + +} + +The declaration double fb; allocates a cell in the store as usual. The value asso- +ciated with fb should be the result of computing f(b). The assignment statement +fb=f(b); is performed in the middle of the condition of the while-statement. +This is another use of assignments as expressions. We prefer the previous solution +as assignments in conditional expressions do not lead to maintainable programs. + +Revision: 6.41 + + 347 + +Answers to the exercises of Chapter 4 + +In the drawings below we have used d (cid:1) and d (cid:2) to denote the two +Answer to 4.1: +parts of d. Each of these parts occupies one storage cell. The structure structx +will occupy 5 cells, and the union unionx requires two cells: + +unionx: + +i, d (cid:1) , or p.x + +, d (cid:2) , or p.y + +structx: + +i + +d (cid:1) + +d (cid:2) + +p.x + +p.y + +Answer to 4.2: The SML datatype for a point in 2-dimensional space is de(cid:2)ned +in the following way: + +datatype coordinate = Polar + +of real * real | +Cartesian of real * real ; + +The equivalent C type-declaration is: + +typedef enum { Polar, Cartesian } coordinatetype ; + +typedef struct { + +coordinatetype tag ; +union { + +struct { + +double x ; +double y ; +} cartesian ; +struct { + +double r ; +double theta ; + +} polar ; +} contents ; +} coordinate ; + +For an argument, say p, of the type coordinate, the type of the coordinate is +stored in p.tag. If the type of the coordinate is Polar, then the radius is stored in +p.contents.polar.r, and the angle is stored in p.contents.polar.theta. +the X and Y-coordinates are stored in +If +p.contents.cartesian.x and p.contents.cartesian.y. + +is a Cartesian coordinate, + +it + +Revision: 6.37 + +(cid:0) + 348 + +AppendixA. Answerstoexercises + +Answer to 4.4: The type pointer to pointer to double can be de(cid:2)ned as follows: + +typedef double ** pointer_to_pointer_to_double ; + +Answer to 4.5: The type type0 is a structure containing two elements: one is a +pointer to a (cid:3)oating point value x, the other is an integer y. The type type1 is a +pointer to a type0 structure. + +Answer to 4.6: This question is not as easy as it might look: + +(a) Yes, *&i has the same value as i: &i is a pointer to i, dereferencing (follow- + +ing) this pointer results in the value of i (123). + +(b) The expression *& (cid:8) + +is only legal if (cid:8) + +is an object with an address (because of +the de(cid:2)nition of the pre(cid:2)x-& operator). For all (cid:8) +is legal, *& (cid:8) +for which & (cid:8) +and (cid:8) denote the same value. In the example functions, the legal values for (cid:8) +are i, p, q, and r. + +(c) The expressions &*p and p denote the same value in almost all cases. In our +example, p is a pointer to i, so the object *p has an address, namely the ad- +dress of i. This is the same value as p. In cases where p contains an illegal +address (they will be explained later), the expression *p is illegal, hence &*p +does not have the same value. + +(d) The expressions &* + +and + +is a legal pointer-value. In any +is the integer 12 or some illegal pointer value, +other case, for example, if +the expressions are not equal. In the example functions, the equality is true +for + +equals p, q, or r. + +are only equal if + +Answer to 4.7: The full code could read: + +#include + +typedef struct { + +double x ; +double y ; + +} point ; + +void print_point( point *p ) { + +printf( "(%f,%f)\n", p->x, p->y ) ; + +} + +void rotate( point *p ) { + +double ty = p->y ; +p->y = -p->x ; +p->x = ty ; + +} + +int main( void ) { + +Revision: 6.37 + +(cid:5) +(cid:5) +(cid:5) +(cid:5) +(cid:5) + 349 + +1, 0 } ; + +point r0 = { +point r1 = { -0.1, -0.3 } ; +point r2 = { 0.7, -0.7 } ; +rotate( &r0 ) ; +print_point( &r0 ) ; +rotate( &r1 ) ; +print_point( &r1 ) ; +rotate( &r2 ) ; +print_point( &r2 ) ; +return 0 ; + +} + +Pay special attention to the implementation of rotate. Because both members of +the input are necessary in the computation of both output members, one needs to +introduce a temporary variable, ty. It can be implemented in a language with a +multiple assignment as: + +(p->y,p->x) = (-p->x,p->y) ; + +Answer to 4.10: + +(a) The * operator expects a pointer and dereferences the pointer. This yields +the value pointed at. The & operator expects a value that it can work out the +address of and returns that address as a pointer. The * operator could be be +viewed as undoing the effect of the & operator. + +(b) The answer printed by the main function is two times the number 3, then +the number 1 (for true), the number 3, two times the number 1 (for true), and +again the number 3. + +(c) The program would print 4 as a result of the following function calls. Firstly: + +twice( add, 2 ) == add( add( 2 ) ) + +Secondly: + +add( add( 2 ) ) == add( 3 ) + +And (cid:2)nally: + +add( 3 ) == 4 + +(d) The differences are the following: + +(cid:1) Program (c) prints 4 and Program (d) prints 14. + +(cid:1) Program (c) can handle only functional arguments with one argument; +Program (d) can handle only functional arguments with two arguments. + +(e) The differences are the following: + +(cid:1) Program (e) can handle functional arguments with any number of argu- +ments and is thus more general than either Program (c) or Program (d). + +(cid:1) Program (e) prints the same answer as Program (d). + +Revision: 6.37 + +(cid:0) + 350 + +AppendixA. Answerstoexercises + +Answer to 4.13: + +(a) Below we de(cid:2)ne a point, and a bounding box in terms of two points: + +typedef struct { int x, y ; } point ; +typedef struct { point ll, ur ; } bbox ; + +(b) The function to normalise makes a bounding box, and ensures that the ll +(cid:2)eld contains the minimum (cid:8) and (cid:2) values, while the ur contains the maxi- +mum values: + +bbox normalise( bbox b ) { + +bbox r ; +if( b.ll.x < b.ur.x ) { + +r.ll.x = b.ll.x ; +r.ur.x = b.ur.x ; + +} else { + +r.ur.x = b.ll.x ; +r.ll.x = b.ur.x ; + +} +if( b.ll.y < b.ur.y ) { + +r.ll.y = b.ll.y ; +r.ur.y = b.ur.y ; + +} else { + +r.ur.y = b.ll.y ; +r.ll.y = b.ur.y ; + +} +return r ; + +} + +(c) The combining function returns the minimum x and y values from the two +ll points of the input boxes in the new ll point, and the maximum in the +ur point: + +bbox combine( bbox b, bbox c ) { + +bbox r ; +r.ll.x = b.ll.x < c.ll.x ? b.ll.x : c.ll.x ; +r.ll.y = b.ll.y < c.ll.y ? b.ll.y : c.ll.y ; +r.ur.x = b.ur.x > c.ur.x ? b.ur.x : c.ur.x ; +r.ur.y = b.ur.y > c.ur.y ? b.ur.y : c.ur.y ; +return r ; + +} + +Note the use of the conditional operator (cid:16)(cid:18)(cid:16)(cid:18)(cid:16) ? (cid:16)(cid:18)(cid:16)(cid:18)(cid:16) : (cid:16)(cid:18)(cid:16)(cid:18)(cid:16) to return the mini- +mum/maximum value. + +(d-g) Below are all the graphic elements. Note that we have de(cid:2)ned separate +types for line, rect and bbox, although they all have the same members. +These data types serve different purposes and therefore it is better to make +them separate types. + +typedef struct { point from, to ; } line ; +typedef struct { point centre ; int radius ; } circ ; + +Revision: 6.37 + +(cid:0) + typedef struct { point c1, c2 ; } rect ; + +typedef enum { Line, Circ, Rect } elementtype ; +typedef struct { + +351 + +elementtype tag ; +union { + +line l ; +circ c ; +rect r ; + +} el ; +} element ; + +(h) The function to calculate the bounding boxes must perform some normalisa- +tions. This is neccessary even when handling a circle, as the radius may be +negative. + +bbox bbox_of_element( element e ) { + +bbox r ; +switch( e.tag ) { + +case Rect : + +r.ll = e.el.r.c1 ; +r.ur = e.el.r.c2 ; +return normalise( r ) ; + +case Line : + +r.ll = e.el.l.from ; +r.ur = e.el.l.to ; +return normalise( r ) ; + +case Circ : + +r.ll.x = e.el.c.centre.x - e.el.c.radius ; +r.ll.y = e.el.c.centre.y - e.el.c.radius ; +r.ur.x = e.el.c.centre.x + e.el.c.radius ; +r.ur.y = e.el.c.centre.y + e.el.c.radius ; +return normalise( r ) ; + +default : + +abort() ; + +} + +} + +(i) The main program (cid:2)nally creates three objects and calls bbox_of_element + +and combine to calculate a (cid:2)nal bounding box: + +int main( void ) { + +rect r = { {3,5}, {5,4} } ; +circ c = { {2,2}, 1 } ; +line l = { {2,2}, {6,1} } ; +element e ; +bbox b; +e.tag = Rect ; e.el.r = r ; +b = bbox_of_element( e ) ; + +Revision: 6.37 + + 352 + +AppendixA. Answerstoexercises + +e.tag = Line ; e.el.l = l ; +b = combine( b, bbox_of_element( e ) ) ; +e.tag = Circ ; e.el.c = c ; +b = combine( b, bbox_of_element( e ) ) ; +printf("Bounding box: (%d,%d) (%d,%d)\n", +b.ll.x, b.ll.y, b.ur.x, b.ur.y ) ; + +return 0 ; + +} + +Revision: 6.37 + + 353 + +Answers to the exercises of Chapter 5 + +Answer to 5.1: + +(cid:0) An SML function to concatenate two arrays s and t is: + +(* concatenate : (cid:146)a array * (cid:146)a array -> (cid:146)a array *) +fun concatenate(s,t) + += let + +val n_s = length(s) +val n_t = length(t) +fun f i = if i < n_s + +then sub(s,i) +else sub(t,i-n_s) + +in + +tabulate(n_s+n_t,f) + +end ; + +Answer to 5.2: +to index u is: + +(cid:0) An SML function to return the data of the array s from index l + +(* slice : (cid:146)a array * int * int -> (cid:146)a array *) +fun slice(s,l,u) = let + +fun f i = sub(s,i+l) + +in + +tabulate(u-l+1,f) + +end ; + +Answer to 5.4: Here is a complete C program that simulates the card game. +Please note that the function player_A does not read secret, but only passes +it on to player_B. + +#include + +typedef enum { false=0, true=1 } bool ; + +#define n_number 4 +#define n_card 3 +typedef int deck[n_card][n_number] ; + +const deck card = {{1,3,5,7},{2,3,6,7},{4,5,6,7}} ; + +bool player_B( int c, int n ) { + +int i ; + +Revision: 6.37 + + AppendixA. Answerstoexercises + +for( i = 0; i < n_number; i++ ) { + +if( card[c][i] == n ) { + +return true ; + +} + +} +return false ; + +354 + +} + +int player_A( int secret ) { + +int guess = 0 ; +int power = 1 ; +int c ; +for( c = 0; c < n_card; c++ ) { +if( player_B( c, secret ) ) { + +guess += power ; + +} +power *= 2 ; + +} +return guess ; + +} + +int main( int argc, char * argv [] ) { + +if( argc != 2 ) { + +printf( "usage: %s [0..7]\n", argv[0] ) ; + +} else { + +; +int secret = argv[1][0] - (cid:146)0(cid:146) +printf( "the secret number is: %d\n", player_A( secret ) ) ; + +} +return 0 ; + +} + +What would happen if the program was tried with 8 or 9 as the secret number? + +In all other cases, the programmer can argue that the index is +Answer to 5.6: +within range. During the initialisation of hist the integer i runs from 0 to u-l, +hence it is within the bounds. The index i in input[ i ] is running from 0 to +some number, but as long as the NULL character has not been seen it is within the +bounds. Similarly, the variable i is in the range 0 . . . u-l-1 when printing the +histogram. + +Note that if it was known a priori that all characters in the input array +, then the bound check before updating + +(cid:146)z(cid:146) + +are always in the range (cid:146)a(cid:146) +. . . +input[ i ] could be removed. + +Answer to 5.7: + +(cid:0) An SML version of histogram using a dynamic array is: + +(* inc : dynamic_array -> int -> dynamic_array *) +fun inc (a,l,u) i = (upd(a,i,sub(a,i)+1),l,u) ; + +Revision: 6.37 + + 355 + +(* histogram : char array -> int -> int -> dynamic_array *) +fun histogram input l u + += let + +val n = length input +val lb = ord(sub(input,0)) +val empty = array_alloc lb lb +fun tally (hist as (_,hist_lb,hist_ub)) i + += let + +val c = ord(sub(input,i)) + +in + +if c < hist_lb + +then inc (extend hist c hist_ub) (c-l) +else if c > hist_ub + +then inc (extend hist hist_lb c) (c-l) +else inc hist (c-l) + +end + +in + +foldl tally empty (0 -- n-1) + +end ; + +Answer to 5.10: + +(a) The function print_three prints the (cid:2)rst three characters of its (string) ar- +If the + +gument. Strings are conventionally terminated by a null character. +string contains fewer than three characters this can be detected. + +void print_three( char s [] ) { + +int i ; +for( i = 0; i < 3; i++ ) { + +if( s[i] == (cid:146)\0(cid:146) + +) { + +return ; + +} else { + +printf( "%c", s[i] ) ; + +} + +} + +} + +(b) The data structure month below has two (cid:2)elds: one to store the number of +days in a month and the other to store the name of the month. Information +from the application domain is used to limit the size of the strings used to +one more than the maximum number of characters in a month (1+9). + +typedef struct { + +int days ; +char name[10] ; + +Revision: 6.37 + +(cid:0) + 356 + +AppendixA. Answerstoexercises + +} month ; + +The array leap as declared below has 12 entries because there are 12 months +in a year: + +month leap [12] = { {31, "January"}, + +{29, "February"}, +{31, "March"}, +{30, "April"}, +{31, "May"}, +{30, "June"}, +{31, "July"}, +{31, "August"}, +{30, "September"}, +{31, "October"}, +{30, "November"}, +{31, "December"} } ; + +(c) The function print_year below prints a table of the name and the number + +of days for each month of a year. + +void print_year( month a_year [] ) { + +int i ; +int total_days = 0 ; +for( i = 0; i < 12; i++) { + +total_days += a_year[i].days ; +print_three( a_year[i].name ) ; +printf( ". has %d days\n", a_year[i].days ) ; + +} +printf( "This year has %d days\n", total_days ) ; + +} + +Answer to 5.11: Here is a complete C program that includes both a discrete ver- +sion of extra_bisection and a main program to test it. + +#include +#include + +typedef enum { false=0, true=1 } bool ; + +int extra_bisection( int (*f)( void *, int ), + +void *x, int l, int h ) { + +int m ; +int f_m ; +while( true ) { + +m = (l + h) / 2 ; +f_m = f( x, m ) ; + +Revision: 6.37 + + 357 + +if( f_m == 0 ) { + +return m ; + +} else if( h-l <= 1 ) { + +return m ; + +} else if( f_m < 0 ) { + +l = m ; + +} else { + +h = m ; + +} + +} + +} + +int direction( void *p, int i ) { + +char ** data = p ; +return strcmp( data[i] , data[0] ) ; + +} + +int main( int argc, char *argv[] ) { + +int i = extra_bisection( direction, argv, 1, argc ) ; +printf( "%d\n", i ) ; +return 0 ; + +} + +Answer to 5.12: + +int findbreak( void *p, int i ) { + +if( brk( i ) == 0 ) { + +return -1 ; + +} +return 1 ; + +} + +int main( void ) { + +int b = extra_bisection( findbreak, NULL, 0, 0x7FFFFFFF ) ; +printf( "Break: %x\n", b ) ; +return 0 ; + +} + +Answer to 5.13: + +(a) Here are two appropriate constants and a typedef suitable to store the + +exam results. + +#define max_student 130 +#define max_module 12 + +Revision: 6.37 + +(cid:0) + 358 + +AppendixA. Answerstoexercises + +typedef int exam [max_student] [max_module] ; + +(b) Here is a function total that computes the sum of all the scores for a partic- + +ular student: + +double total( exam table, int student ) { + +int m ; +int t = 0 ; +for( m = 0; m < max_module; m++ ) { + +t += table[student][m] ; + +} +return t ; + +} + +(c) Here is a function print to display the exam results nicely formatted: + +void print( exam table ) { + +int s, m ; +bool ok = true ; +for( s = 0; s < max_student; s++ ) { + +int n = non_zero( table, s ) ; +if( n > 0 ) { + +int t = total( table, s ) ; +printf( "%4d:", s ) ; +for( m = 0; m < max_module; m++ ) { +printf( "%3d", table[s][m] ) ; +if( table[s][m] < 0 || table[s][m] > 100 ) { + +printf( "?" ) ; +ok = false ; + +} else { + +printf( " " ) ; + +} + +} +printf( "%4d %4d %6.2f\n", t, n, (double) t / + +(double) n ) ; + +} + +} +printf( "exam results " ) ; +if( ok ) { + +printf( "ok\n" ) ; + +} else { + +printf( "not ok\n" ) ; + +} + +} + +The print function uses an auxiliary function: + +int non_zero( exam table, int student ) { + +int m ; + +Revision: 6.37 + + 359 + +int n = 0 ; +for( m = 0; m < max_module; m++ ) { +if( table[student][m] != 0 ) { + +n ++ ; + +} + +} +return n ; + +} + +(d) Here is a main program that initialises the table to some arbitrary values and + +then prints it. + +int main( void ) { + +{ exam table = {{1,2,3},{4,5,6,7},{0},{8},{-3}} ; + +print( table ) ; + +} +{ exam table = {{1,2,3},{4,5,6,7},{0},{8},{3}} ; + +print( table ) ; + +} +return 0 ; + +} + +(e) Code has been included to check that when printing the table, each score +is within the permitted range. The program prints (cid:148)exam results ok(cid:148) if all +scores are within range and it prints (cid:148)exam results not ok(cid:148) otherwise. Each +offending score is also accompanied by a question mark. + +Answer to 5.14: +sheet. + +(cid:0) Here are the C data structures required to support the spread + +(a) The maximum number of work sheets is max_sheet: + +#define max_sheet 5 +typedef sheet work[max_sheet] ; + +(b) The name, date and time identify a work sheet: + +#define max_name 10 +typedef char name[max_name] ; + +typedef struct { +int the_day ; +int the_month ; +int the_year ; + +} date ; + +typedef struct { +int the_hour ; +int the_minute ; + +Revision: 6.37 + + 360 + +AppendixA. Answerstoexercises + +} time ; + +(c) A work sheet is a collection of cells with their identi(cid:2)cation: + +#define max_row 10 +#define max_column 10 +typedef struct { + +name the_name ; +date the_date ; +time the_time ; +cell the_cell[max_row][max_column] ; + +} sheet ; + +(d) Here is the type of all possible cell values: + +#define max_formula 80 +typedef char formula[max_formula] ; + +typedef union { + +formula the_formula ; +int +float +bool +} value ; + +the_int ; +the_real ; +the_bool ; + +(e) Here are the four different cell kinds: + +typedef enum { Formula, Int, Real, Bool } kind ; + +(f) A cell has a (cid:3)ag to tell whether it is in use: + +typedef struct { +bool in_use ; +kind the_kind ; +value the_value ; + +} cell ; + +Answer to 5.15: + +(cid:0) Here is a C program to print magic squares of order + +(cid:16)(cid:21)(cid:16)(cid:18)(cid:16) + +(cid:6) . + +#include + +#define maxmax 17 +typedef int magic[maxmax][maxmax] ; + +void zero( magic square, int max ) { + +int row, col ; +for( row = 0; row < max; row ++ ) { + +for( col = 0; col < max; col++ ) { + +square[row][col] = 0 ; + +} + +} + +} + +Revision: 6.37 + +(cid:0) +(cid:14) +(cid:2) +(cid:14) +(cid:9) +(cid:0) + 361 + +void fill( magic square, int max ) { + +int row = 0 ; +int col = max / 2 ; +int cnt = 0 ; +while( cnt < max*max ) { + +if( square[row][col] == 0 ) { + +cnt++ ; +square[row][col] = cnt ; +col = (col + max - 1) % max ; +row = (row + max - 1) % max ; + +} else { + +col = (col + 1) % max ; +row = (row + 2) % max ; + +} + +} + +} + +void print( magic square, int max ) { + +int row, col ; +for( row = 0; row < max; row ++ ) { + +for( col = 0; col < max; col++ ) { + +printf( "%4d", square[row][col] ) ; + +} +printf( "\n" ) ; + +} + +} + +int main( void ) { + +int max ; +magic square ; +for( max = 1; max <= maxmax; max += 2 ) { + +zero( square, max ) ; +fill( square, max ) ; +print( square, max ) ; +printf( "\n" ) ; + +} +return 0 ; + +} + +Revision: 6.37 + + 362 + +AppendixA. Answerstoexercises + +Answers to the exercises of Chapter 6 + +Answer to 6.1: +statement. + +(cid:0) The following C procedure prints a character list using a while- + +void print_list( char_list x_xs ) { + +while( x_xs != NULL ) { + +printf( "%c", head( x_xs ) ) ; +x_xs = tail( x_xs ) ; + +} + +} + +Answer to 6.2: + +typedef enum { Cons, Nil } char_list_tags ; + +typedef struct char_list { + +char_list_tags tag ; +union { + +struct { +char +list_head ; +struct char_list * list_tail ; + +} cons_cell ; + +} char_list_union ; + +} *char_list ; + +The alternative, corresponding to the tag Nil, does not hold any information. In +such a case, where there is only one alternative that holds information, the union +is not necessary, and the type can be simpli(cid:2)ed to: + +typedef enum { Cons, Nil } char_list_tags ; +typedef struct char_list { + +tag ; +char_list_tags +char +list_head ; +struct char_list * list_tail ; + +} *char_list ; + +Each list must now be terminated with an extra element with a tag-value Nil. +The inef(cid:2)ciency of managing these cells that terminate lists is the reason that C +uses a special pointer value NULL to terminate a list. + +Answer to 6.3: + +(cid:0) A tail recursive version of length is: + +(* length : char_list -> int *) +fun length x_xs + += length(cid:146) 0 x_xs + +Revision: 6.34 + + 363 + +(* length(cid:146) : int -> char_list -> int *) +and length(cid:146) accu x_xs = if x_xs = Nil + +The while-schema of Chapter 3 and suitable simpli(cid:2)cation yields the following ef- +(cid:2)cient C implementation. + +then accu +else length(cid:146) (accu+1) (tail x_xs) ; + +int length( char_list x_xs ) { + +int accu = 0 ; +while( x_xs != NULL ) { + +accu++ ; +x_xs = tail( x_xs ) ; + +} +return accu ; + +} + +Answer to 6.4: The C implementation of nth shown below aborts with an error +message when a non-existent list element is accessed. It is the result of using the +general while-schema of Chapter 3. + +char nth( char_list x_xs, int n ) { + +while( true ) { + +if( x_xs == NULL ) { + +printf( "nth\n" ) ; +abort() ; + +} +if ( n == 0 ) { + +return head( x_xs ) ; + +} +x_xs = tail( x_xs ) ; +n-- ; + +} + +} + +Answer to 6.5: + +(cid:0) A recursive de(cid:2)nition of append without pattern matching is: + +(* append : char_list -> char_list -> char_list *) +fun append x_xs ys + += if x_xs = Nil + +then ys +else Cons(head x_xs,append (tail x_xs) ys) ; + +Revision: 6.34 + + 364 + +AppendixA. Answerstoexercises + +Answer to 6.6: Filtering a sequence (cid:3) +certain predicate (cid:12) can be speci(cid:2)ed as follows: + +to select only the elements that satisfy a + +(cid:5)(cid:9)(cid:2) + +(cid:1)(cid:3)(cid:2) + +(cid:4)-(cid:10) + +(cid:2)lter + +(cid:2)lter + +squash + +(cid:27) domain + +The set comprehension above does not produce a sequence, but a mere set of +maplets. +It is not a sequence because there may be ‘holes’ in the domain. The +auxiliary function ‘squashes’ the domain so that all the holes are removed. Here is +the de(cid:2)nition of squash: + +(cid:1)(cid:3)(cid:2) + +(cid:8)(cid:11)(cid:10) + +(cid:1).(cid:2) + +squash (cid:0) + +squash + +!(cid:27) domain + +(cid:23)(cid:26)% + +(cid:16)(cid:18)(cid:16)(cid:18)(cid:16) + +(cid:1)(cid:0) domain + +Answer to 6.7: +the following sequence: + +(cid:0) Mapping a function (cid:0) over all elements of a sequence (cid:3) delivers + +map (cid:0) + +map + +(cid:5)(cid:7)(cid:2) + +(cid:1)(cid:3)(cid:2) + +(cid:4)-(cid:10) + +(cid:11)(cid:8) + +(cid:3)(cid:2) + +(cid:3)(cid:2) + +(cid:27) domain + +Answer to 6.9: The general version of map is extra_map: + +char_list extra_map( char (*f)( void *, char ), + +void * arg, char_list x_xs ) { + +if( x_xs == NULL ) { + +return NULL ; + +} else { + +char x = head( x_xs ) ; +char_list xs = tail( x_xs ) ; +return cons( f( arg, x ), extra_map( f, arg, xs ) ) ; + +} + +} + +Answer to 6.10: +using foldr, is: + +(cid:0) A version of copy that traverses the input list from the right, + +(* copy : char_list -> char_list *) +fun copy xs = let + +val n = length xs +fun copy(cid:146) i accu = Cons(nth xs i,accu) + +in + +foldr copy(cid:146) Nil (0 -- n-1) + +end ; + +Revision: 6.34 + +(cid:0) +(cid:1) +(cid:1) +(cid:10) +(cid:2) +(cid:0) +(cid:4) +(cid:10) +(cid:1) +(cid:8) +(cid:10) +(cid:1) +(cid:8) +(cid:1) +(cid:12) +(cid:14) +(cid:3) +(cid:8) +(cid:0) +(cid:1) +(cid:23) +(cid:0) +(cid:0) +(cid:10) +(cid:3) +(cid:1) +(cid:0) +(cid:8) +(cid:29) +(cid:0) +(cid:1) +(cid:3) +(cid:8) +’ +(cid:12) +(cid:1) +(cid:3) +(cid:1) +(cid:0) +(cid:8) +(cid:8) +* +(cid:8) +(cid:4) +(cid:10) +(cid:1) +(cid:4) +(cid:10) +(cid:1) +(cid:8) +(cid:1) +(cid:3) +(cid:8) +(cid:0) +(cid:23) +(cid:1) +(cid:0) +(cid:0) +(cid:0) +(cid:8) +(cid:0) +(cid:10) +(cid:3) +(cid:1) +(cid:0) +(cid:8) +(cid:29) +(cid:0) +(cid:1) +(cid:3) +(cid:8) +’ +(cid:0) +(cid:0) +(cid:8) +(cid:1) +(cid:0) +* +(cid:1) +(cid:3) +(cid:8) +(cid:8) +* +(cid:1) +(cid:1) +(cid:10) +(cid:4) +(cid:10) +(cid:1) +(cid:8) +(cid:10) +(cid:1) +(cid:0) +(cid:14) +(cid:3) +(cid:8) +(cid:0) +(cid:23) +(cid:0) +(cid:0) +(cid:10) +(cid:0) +(cid:1) +(cid:3) +(cid:1) +(cid:0) +(cid:8) +(cid:8) +(cid:29) +(cid:0) +(cid:1) +(cid:3) +(cid:8) +* + The for-schema can be used to translate this function into C. After simpli(cid:2)cation +this yields: + +365 + +char_list copy( char_list xs ) { + +int i ; +int n = length( xs ) ; +char_list accu = NULL ; +for( i = n-1; i >= 0; i-- ) { + +accu = cons( nth( xs, i ), accu ) ; + +} +return accu ; + +} + +Answer to 6.11: Using the similarity between copy and append, the following +programming can be derived straightforwardly: + +char_list append( char_list xs, char_list ys ) { + +char_list accu = ys ; +char_list *last = &accu ; +while( xs != NULL ) { + +char_list new = cons( head( xs ), ys ) ; +*last = new ; +last = &new->list_tail ; +xs = tail( xs ) ; + +} +return accu ; + +} + +Answer to 6.12: +function can be derived: + +(cid:0) Using the similarity between map and copy, the following + +char_list map( char (*f)( char ), char_list xs ) { + +char_list accu = NULL ; +char_list *last = &accu ; +while( xs != NULL ) { + +char_list new = cons( f( head( xs ) ), NULL ) ; +*last = new ; +last = &new->list_tail ; +xs = tail( xs ) ; + +} +return accu ; + +} + +Note that by using the advanced pointer technique the resulting function is +shorter. + +Revision: 6.34 + + 366 + +AppendixA. Answerstoexercises + +Answer to 6.13: Using the similarity between copy and filter, the following +program can be derived: + +char_list filter( bool (*pred)( char ), char_list xs ) { + +char_list accu = NULL ; +char_list *last = &accu ; +while( xs != NULL ) { + +const char x = head( xs ) ; +if( pred( x ) ) { + +char_list new = cons( x, NULL ) ; +*last = new ; +last = &new->list_tail ; + +} +xs = tail( xs ) ; + +} +return accu ; + +} + +(cid:0) The recursive function that transfers the elements of an array +Answer to 6.14: +into a list follows. It is inef(cid:2)cient, since it needs an amount of stack space propor- +tional to the length of the array. The solution uses an auxiliary function traverse +to traverse the index range l . . . u. + +(* array_to_list : char array -> char_list *) +fun array_to_list s + += let + +val l = 0 +val u = length s - 1 +fun traverse s i u += if i < u + +then Cons(sub(s, i), traverse s (i+1) u) +else Nil + +in + +traverse s l u + +end ; + +The translation of traverse to C is an application of the multiple argument +while-schema: + +char_list traverse( char s[], int i, int u ) { + +if( i < u ) { + +return cons( s[i], traverse( s, i+1, u ) ) ; + +} else { + +return NULL ; + +} + +} + +Revision: 6.34 + + 367 + +char_list array_to_list( char s[], int n ) { + +int l = 0 ; +int u = n - 1; +return traverse( s, l, u ) ; + +} + +Answer to 6.18: The speci(cid:2)cation of reverse is: + +(cid:1).(cid:2) + +(cid:8)(cid:11)(cid:10) + +(cid:1)(cid:3)(cid:2) + +reverse + +reverse + +(cid:0)(cid:7)(cid:0) + +(cid:11)(cid:27) domain + +Here is an ef(cid:2)cient C function to reverse a list: + +char_list reverse( char_list x_xs ) { + +char_list accu = NULL ; +while( x_xs != NULL ) { + +accu = cons( head( x_xs ), accu ) ; +x_xs = tail( x_xs ) ; + +} +return accu ; + +} + +Answer to 6.19: + +(a) Here are the C #define and typedef declarations that describe a binary + +tree with integers at the leaves: + +typedef enum {Branch, Leaf} tree_tag ; + +#define tree_struct_size sizeof( struct tree_struct ) + +typedef struct tree_struct { + +tree_tag tag ; +union { + +int leaf ; +struct { + +struct tree_struct * left ; +struct tree_struct * right ; +} branch ; + +} alt ; + +} * tree_ptr ; + +/* tag Leaf */ +/* tag Branch */ + +Revision: 6.34 + +(cid:0) +(cid:4) +(cid:10) +(cid:1) +(cid:4) +(cid:10) +(cid:1) +(cid:8) +(cid:1) +(cid:3) +(cid:8) +(cid:0) +(cid:23) +(cid:0) +(cid:0) +(cid:10) +(cid:3) +(cid:1) +(cid:8) +(cid:3) +(cid:0) +(cid:0) +(cid:8) +(cid:29) +(cid:0) +(cid:1) +(cid:3) +(cid:8) +* +(cid:0) + 368 + +AppendixA. Answerstoexercises + +(b) The function mkLeaf creates a leaf node of a binary tree: + +tree_ptr mkLeaf( int leaf ) { + +tree_ptr tree ; +tree = malloc( tree_struct_size ) ; +if( tree == NULL ) { + +printf( "mkLeaf: no space\n" ) ; +abort( ) ; + +} +tree->tag = Leaf ; +tree->alt.leaf = leaf ; +return tree ; + +} + +The function mkBranch creates an interior node of a binary tree: + +tree_ptr mkBranch( tree_ptr left, tree_ptr right ) { + +tree_ptr tree ; +tree = malloc( tree_struct_size ) ; +if( tree == NULL ) { + +printf( "mkBranch: no space\n" ) ; +abort( ) ; + +} +tree->tag = Branch ; +tree->alt.branch.left = left ; +tree->alt.branch.right = right ; +return tree ; + +} + +(c) Here is a function to print a binary tree: + +void print( tree_ptr tree ) { + +switch( tree->tag ) { +case Leaf : + +printf( "%d", tree->alt.leaf ) ; +break ; + +case Branch : + +printf( "(" ) ; +print( tree->alt.branch.left ) ; +printf( "," ) ; +print( tree->alt.branch.right ) ; +printf( ")" ) ; +break ; + +} + +} + +(d) Here is an SML function to rotate a tree: + +(* rotate : tree -> tree *) + +Revision: 6.34 + + 369 + +fun rotate (Leaf(key)) + += Leaf(key) + +| rotate (Branch(l,r)) = Branch(rotate r,rotate l) ; + +The C function below rotates a tree without changing the input tree. + +tree_ptr rotate( tree_ptr tree ) { + +switch( tree->tag ) { +case Leaf : + +return mkLeaf ( tree->alt.leaf ) ; + +case Branch : + +return mkBranch ( rotate ( tree->alt.branch.right ), + +rotate ( tree->alt.branch.left ) ) ; + +} + +} + +Answer to 6.20: + +(a) The type tree_ptr de(cid:2)nes a pointer to a structure that can either accommo- +date a binding or a node of a tree. Each tree node contains a key (cid:2)eld that +will correspond to the constructor in SML, and it contains a (pointer to an) +array with sub trees. The number of sub trees is stored in the size-member. +(b) The functions mkBind and mkData allocate a tree_struct. Both functions +print out the data such that the execution of the functions can be traced. The +pointers returned by malloc should be checked for a NULL value. + +tree_ptr mkBind( tree_ptr * b ) { + +tree_ptr tree ; +tree = malloc( sizeof( struct tree_struct ) ) ; +tree->tag = Bind ; +tree->alt.bind = b ; +printf( "mkBind( %p ): %p\n", b, tree ) ; +return tree ; + +} + +tree_ptr mkData( char k, int s, ... ) { + +va_list ap ; +int i ; +tree_ptr tree ; +tree = malloc( sizeof( struct tree_struct ) ) ; +tree->tag = Data ; +tree->alt.comp.key = k ; +tree->alt.comp.size = s ; +tree->alt.comp.data = calloc( s, sizeof( tree_ptr ) ) ; +printf( "mkData( %d, %d", k, s ) ; +va_start( ap, s ) ; +for( i = 0; i < s; i++ ) { + +tree_ptr d = va_arg( ap, tree_ptr ) ; + +Revision: 6.34 + + 370 + +AppendixA. Answerstoexercises + +tree->alt.comp.data[i] = d ; +printf( ", %p", d ) ; + +} +va_end( ap ) ; +printf( " ): %p\n", tree ) ; +return tree ; + +} + +The %p format prints a pointer. + +(c) The function match performs case analysis on the argument pat. If it is a +binding, the value of exp is stored in the appropriate location. If we are deal- +ing with Data, sub trees will be matched, provided that the key and size of +the pattern and expression agree. + +bool match( tree_ptr pat, tree_ptr exp ) { + +switch( pat->tag ) { + +case Bind : + +* (pat->alt.bind) = exp ; +return true ; + +case Data : + +if ( exp->tag == Data && + +exp->alt.comp.key == pat->alt.comp.key && +exp->alt.comp.size == pat->alt.comp.size ) { + +int i ; +for( i = 0; i < pat->alt.comp.size; i++ ) { + +if( ! match( pat->alt.comp.data[i], + +exp->alt.comp.data[i] ) ) { + +return false ; + +} + +} +return true ; + +} else { + +return false ; + +} + +} +abort() ; + +} + +(d) The main function below creates a pattern and an expression. It then tries to +match both, which will succeed. This binds the sub tree with key (cid:146)B(cid:146) +to the +to d. The second call +variable b, the sub tree (cid:146)C(cid:146) +to match fails, because the keys and sizes of pat and b disagree. The third +call to match also fails, because the keys of pat and c disagree, even though +their sizes do agree. The last call to match succeeds. + +to c and the sub tree (cid:146)D(cid:146) + +int main( void ) { + +tree_ptr a, b, c, d ; +tree_ptr exp = mkData( (cid:146)A(cid:146), + +3, + +Revision: 6.34 + + 371 + +mkData( (cid:146)B(cid:146), +mkData( (cid:146)C(cid:146), +mkData( (cid:146)D(cid:146), + +0 ), +0 ), +3, + +mkData( (cid:146)E(cid:146), +mkData( (cid:146)F(cid:146), +mkData( (cid:146)G(cid:146), + +0 ), +0 ), +0 ) ) ) ; + +tree_ptr pat = mkData( (cid:146)A(cid:146), + +3, +mkBind( &b ), +mkBind( &c ), +mkBind( &d ) ) ; + +if( match( pat, exp ) ) { + +printf( "1: b=%p, c=%p, d=%p\n", b, c, d ) ; + +} +if( match( pat, b ) ) { + +printf( "2: b=%p, c=%p, d=%p\n", b, c, d ) ; + +} +if( match( pat, c ) ) { + +printf( "3: b=%p, c=%p, d=%p\n", b, c, d ) ; + +} +if( match( mkBind( &a ), exp ) ) { + +printf( "4: a=%p\n", a ) ; + +} +return 0 ; + +} + +Revision: 6.34 + + 372 + +AppendixA. Answerstoexercises + +Answers to the exercises of Chapter 7 + +Answer to 7.2: + +(cid:0) Here is stream_to_list using pointers to pointers. + +char_list stream_to_list( FILE * stream ) { + +char_list accu = NULL ; +char_list *last = &accu ; +int c ; +while( ( c = getc( stream ) ) != EOF ) { + +char_list new = cons( c, NULL ) ; +*last = new ; +last = & new->list_tail ; + +} +return accu ; + +} + +Answer to 7.4: +stream: + +(cid:0) Here is a side effecting SML function to output a list to a + +(* list_to_stream : outstream -> char list -> unit *) +fun list_to_stream stream [] + += () + +| list_to_stream stream (x::xs) + += (output(stream,x); list_to_stream stream xs) ; + +The C equivalent is: + +void list_to_stream( FILE * stream, char_list list ) { + +while( list != NULL ) { + +putc( head( list ), stream ) ; +list = tail( list ) ; + +} + +} + +Answer to 7.6: + +(cid:0) A tail recursive version of word_count is: + +(* word_count : char list -> char list -> int *) +fun word_count ws ts + += let + +fun count accu ws ts += if ts = [] + +then accu +else if match ws ts + +then count (accu+1) ws (tail ts) + +Revision: 6.33 + + else count accu + +ws (tail ts) + +373 + +in + +count 0 ws ts + +end ; + +The C implementation of the tail-recursive word_count is: + +int word_count( char_list ws, char_list ts ) { + +int accu = 0 ; +while( true ) { + +if( ts == NULL ) { +return accu ; + +} else { + +if( match( ws, ts ) ) { + +accu++ ; + +} +ts = tail( ts ) ; + +} + +} + +} + +Answer to 7.7: + +(cid:0) An ef(cid:2)cient C implementation of match is: + +bool match( char_list ws, char_list ts ) { + +while( true ) { + +if( ws == NULL ) { +return true ; + +} else if( ts == NULL ) { + +return false ; + +} else if( head( ws ) == head( ts ) ) { + +ws = tail( ws ) ; +ts = tail( ts ) ; + +} else { + +return false ; + +} + +} + +} + +Answer to 7.8: +the word (cid:147)cucumber(cid:148) on the stdin stream: + +(cid:0) Here is a main program to count the number of occurrences of + +int main( void ) { + +char_list word = array_to_list( "cucumber", 8 ) ; +char_list text = stream_to_list( stdin ) ; +printf( "%d\n", word_count( word, text ) ) ; +return 0 ; + +Revision: 6.33 + + 374 + +} + +AppendixA. Answerstoexercises + +Answer to 7.9: Here is the SML version of stream_to_list which accesses at +most n elements: + +(* stream_to_list : instream -> int -> char list *) +fun stream_to_list stream n + += if end_of_stream stream orelse n = 0 + +then [] +else input(stream,1) :: stream_to_list stream (n-1) ; + +The corresponding C version is: + +char_list stream_to_list( FILE * stream, int n ) { + +int c = getc( stream ) ; +if( c == EOF || n == 0 ) { + +return NULL ; + +} else { + +return cons( c, stream_to_list( stream, n-1 ) ) ; + +} + +} + +Answer to 7.10: +number of occurrences of some word in a text. + +(cid:0) Here is a main program to initialise the queue and count the + +int main( void ) { + +char_list word = array_to_list( "cucumber", 8 ) ; +char_queue text = create( stdin, length( word ) ) ; +printf( "cucumber: %d times\n", word_count( word, text ) ) ; +return 0 ; + +} + +Answer to 7.11: +the array based queue. + +(cid:0) The function valid returns the number of valid elements in + +(* valid : (cid:146)a queue -> int *) +fun valid (Queue (stream, valid, array)) = valid ; + +In C, this becomes: + +int valid( char_queue q ) { +return q->queue_valid ; + +} + +Revision: 6.33 + + Answer to 7.12: +using arrays. + +(cid:0) Here are the SML and C versions of word_count and match + +375 + +(* list_match : char list -> char list -> bool *) +fun list_match [] + +t + +| list_match (w::ws) [] +| list_match (w::ws) (t::ts) = w = (t:char) andalso + += true += false + +(* match : char list -> char array -> bool *) +fun match ws ts = list_match ws (array_to_list ts) ; + +list_match ws ts ; + +bool list_match( char_list ws, char_list ts ) { + +while( true ) { + +if( ws == NULL ) { +return true ; + +} else if( ts == NULL ) { + +return false ; + +} else if( head( ws ) == head( ts ) ) { + +ws = tail( ws ) ; +ts = tail( ts ) ; + +} else { + +return false ; + +} + +} + +} + +bool match( char_list ws, char ts[], int n ) { + +return list_match( ws, array_to_list( ts, n ) ) ; + +} + +int word_count( char_list ws, char_queue ts ) { + +int accu = 0 ; +while( ! is_empty( ts ) ) { + +if( match( ws, fetch( ts ), valid( ts ) ) ) { + +accu++ ; + +} +advance( ts ) ; + +} +return accu ; + +} + +Answer to 7.14: We need an auxiliary function to free a list; this function has +been de(cid:2)ned in Chapter 6. + +Revision: 6.33 + + 376 + +AppendixA. Answerstoexercises + +void free_list( char_list xs ) { + +while( xs != NULL ) { + +const char_list last = xs ; +xs = tail( xs ) ; +free( last ) ; + +} + +} + +The function qsort is going to be modi(cid:2)ed so that qsort(x) will only allocate +those cells that are necessary to hold the result list. It will not allocate more cells, +nor will it destroy any cells of the input list. + +char_list qsort( char_list p_xs ) { + +if( p_xs == NULL) { + +return NULL ; + +} else { +char +p = head( p_xs ) ; +char_list xs = tail( p_xs ) ; +char_list less = extra_filter( less_eq, &p, xs ) ; +char_list more = extra_filter( greater, &p, xs ) ; +char_list sorted_less = qsort( less ) ; +char_list sorted_more = qsort( more ) ; +char_list pivot = cons( p, NULL ) ; +char_list sorted = append( sorted_less, + +append( pivot, sorted_more ) ) ; + +free_list( pivot ) ; +free_list( less ) ; +free_list( more ) ; +free_list( sorted_less ) ; +return sorted ; + +} + +} + +Therefore, + +There are a number of interesting points to note. The function append is +asymmetrical +in that it copies its (cid:2)rst argument but reuses the second ar- +the lists sorted_more and the result of the function +gument. +append( pivot, sorted_more ) should not be deallocated. Note that one +can optimise the code slightly further, as it is not necessary to create the pivot- +node with a NULL-tail, because the next statement appends sorted_more. A +more ef(cid:2)cient solution is where pivot is not copied by append and deallocated +later on: + +... +char_list pivot = cons( p, sorted_more ) ; +char_list sorted = append( sorted_less, pivot ) ; +free_list( less ) ; +... + +Adding the garbage collection is essential, no system can work with a memory +leak. It is also clear that cluttering the code with deallocations is not pretty. Some- + +Revision: 6.33 + + 377 + +times this can be improved by de(cid:2)ning functions in such a way that they do de- +stroy their arguments. As an example, we could split the list p_xs destructively +into pivot, less, and more, and append could destructively append its argu- +ments. In that case, qsort would destroy its argument, and one can write a quick- +sort that does not have to allocate or free any cells. In order to create a functional +interface to the function, one needs an auxiliary function quicksort that (cid:2)rst +copies its argument before calling the destructive qsort. + +Answer to 7.15: + +(cid:0) Here is an SML function main to call qsort on the data: + +(* main : char list *) +val main = qsort (explode "ECFBACG") ; + +Here is the corresponding C version: + +int main( void ) { + +char_list sorted = qsort( array_to_list( "ECFBACG", 7 ) ) ; +list_to_stream( stdout, sorted ) ; +putchar( (cid:146)\n(cid:146) +return 0 ; + +) ; + +} + +Answer to 7.16: + +void qsort( char data [], int l, int r ) { + +if( l < r) { + +int p = l ; +char data_p = data[p] ; +int i = l ; +int j = r ; +while( true ) { + +i = up( +data_p, data, i, r ) ; +j = down( data_p, data, l, j ) ; +if( i < j ) { + +swap( data, i, j ) ; +i++ ; +j-- ; + +} else if( i < p ) { + +swap( data, i, p ) ; +i++ ; +break ; + +} else if( p < j ) { + +swap( data, p, j ) ; +j-- ; +break ; + +} else { + +break ; + +Revision: 6.33 + + 378 + +AppendixA. Answerstoexercises + +} + +} +qsort( data, l, j ) ; +qsort( data, i, r ) ; + +} + +} + +Answer to 7.19: +supplied through argc and argv: + +(cid:0) Here is a complete C program to bubble sort its arguments + +#include +#include + +void swap( char * data[], int i, int j ) { + +char * data_i = data[i] ; +char * data_j = data[j] ; +data[i] = data_j ; +data[j] = data_i ; + +} + +void bubble_sort( char * data [], int l, int r ) { + +int i,k ; +for( i = l; i < r; i++ ) { + +for( k = i+1; k <= r; k++ ) { + +if( strcmp( data[i], data[k] ) > 0 ) { + +swap( data, i, k ) ; + +} + +} + +} + +} + +int main( int argc, char * argv [] ) { + +int i ; +bubble_sort( argv, 1, argc-1 ) ; +printf( "%s", argv[0] ) ; +for( i = 1; i < argc; i++ ) { +printf( " %s", argv[i] ) ; + +} +printf( "\n" ) ; +return 0 ; + +} + +Answer to 7.21: Here is a complete C program implementing the Caesar cipher +encryption and decryption method for streams. + +Revision: 6.33 + + 379 + +#include +#include + +void crypt( FILE * in, FILE * out, int k ) { + +char c ; +while( (c = getc( in ) ) != EOF ) { + +putc( c + k, out ) ; + +} + +} + +int main( int argc, char * argv [] ) { + +if( argc != 2 ) { + +printf( "usage: %s [+|-]number\n", argv[0] ) ; +return 1 ; + +} else { + +char * rest ; +int k = strtol( argv[1], &rest, 10 ) ; +) { +if( *rest != (cid:146)\0(cid:146) + +printf( "usage: %s illegal argument %s\n", + +argv[0], argv[1] ) ; + +return 1 ; + +} else { + +crypt( stdin, stdout, k ) ; +return 0 ; + +} + +} + +} + +Revision: 6.33 + + 380 + +AppendixA. Answerstoexercises + +Answers to the exercises of Chapter 8 + +Answer to 8.1: + +graphics.o: graphics.c graphics.h matrix.h vector.h + +cc -c graphics.c + +Answer to 8.2: The combined make (cid:2)le is: + +vector.o: vector.c vector.h + +cc -c vector.c + +matrix.o: matrix.c matrix.h vector.h + +cc -c matrix.c + +graphics.o: graphics.c graphics.h matrix.h vector.h + +cc -c graphics.c + +The dependency graph is: + +cc -c graphics.c + +graphics.o + +cc -c vector.c + +vector.o + +cc -c matrix.c + +matrix.o + +graphics.c + +graphics.h + +vector.c + +vector.h + +matrix.c + +matrix.h + +Answer to 8.3: Following the arrows shows that graphics.o, matrix.o, and +graphics need to be remade if matrix.h is changed. + +Revision: 6.38 + + cc -c graphics.c + +graphics.o + +cc -o graphics ... + +cc -c vector.c + +graphics + +vector.o + +cc -c matrix.c + +matrix.o + +381 + +graphics.c + +graphics.h + +vector.c + +vector.h + +matrix.c + +matrix.h + +The objects graphics.o and matrix.o must be remade before graphics is +made, but they can be compiled in any order. + +Answer to 8.8: The iterative version of length which operates on polymorphic +lists is: + +int length( list x_xs ) { + +int accu = 0 ; +while( x_xs != NULL ) { + +accu++ ; +x_xs = tail( x_xs ) ; + +} +return accu ; + +} + +The iterative version of nth for polymorphic lists is: + +void * nth( list x_xs, int n ) { + +while( n != 0 ) { + +x_xs = tail( x_xs ) ; +n-- ; + +} +return head( x_xs ) ; + +} + +Answer to 8.9: The polymorphic open list version of append with advanced use +of pointers is: + +list append( list xs, list ys, int size ) { + +list accu = ys ; +list *lastptr = &accu ; +while( xs != NULL ) { + +list new = cons( head( xs ), ys, size ) ; + +Revision: 6.38 + + 382 + +AppendixA. Answerstoexercises + +*lastptr = new ; +lastptr = & new->list_tail ; +xs = tail( xs ) ; + +} +return accu ; + +} + +Answer to 8.10: Here is a memoising version of the factorial function: + +#define MAX 12 + +int fac( int n ) { + +static int memo[MAX] = {1,0} ; +if( n < 1 || n > MAX ) { + +abort( ) ; + +} else { + +int r = memo[n-1] ; +if( r == 0 ) { + +r = n * fac( n-1 ) ; +memo[n-1] = r ; + +} +return r ; + +} + +} + +Answer to 8.11: This answer only gives the header (cid:2)le for the polymorphic array +ADT: + +typedef struct Array *Array ; + +extern Array arraynew( int l, int u, int size ) ; +extern void arrayextend( Array a, int l, int u ) ; +extern void arraystore( Array a, int index, void *value ) ; +extern void* arrayload( Array a, int index ) ; + +The structure used in the implementation is: + +struct Array { +int l, u ; +int size ; +void **data ; /* Store pointers to elements */ + +/* Store current bounds of array */ +/* Store size of elements in array */ + +} ; + +Answer to 8.13: + +Revision: 6.38 + +(cid:0) + 383 + +(a) Here are the functions snoc, head and tail that operate on a snoc list: +snoc_list snoc( snoc_list head, void * tail ) { + +snoc_list l = malloc( sizeof( struct snoc_struct ) ) ; +if( l == NULL ) { + +printf( "snoc: no space\n" ) ; +abort( ) ; + +} +l->snoc_head = head ; +l->snoc_tail = tail ; +return l ; + +} + +snoc_list head( snoc_list l ) { + +return l->snoc_head ; + +} + +void * tail( snoc_list l ) { + +return l->snoc_tail ; + +} + +(b) The function sprint is recursive because it must print the elements of the +snoc list in the correct order. Care has been taken to avoid printing a comma +at the beginning or at the end of the list. + +void sprint( void (* print) ( void * ), snoc_list xs ) { + +if( xs != NULL ) { + +snoc_list ys = head( xs ) ; +if( ys != NULL ) { + +sprint( print, ys ) ; +printf( "," ) ; + +} +print( tail( xs ) ) ; + +} + +} + +(c) Here is a main function and an auxiliary function to test the snoc type and + +associated functions: + +void print_elem( void * p ) { + +int i = (int) p ; +printf( "%d", i ) ; + +} + +int main( void ) { + +snoc_list sl = snoc( snoc( NULL, (void *) 1 ), (void *) 2 ) ; +sprint( print_elem, sl ) ; +printf( "\n" ) ; +return 0 ; + +} + +Revision: 6.38 + + 384 + +AppendixA. Answerstoexercises + +Answer to 8.14: + +(a) Here are the C type de(cid:2)nitions that represent an ntree: + +typedef enum {Br, Lf} ntree_tag ; + +typedef struct ntree_struct { + +ntree_tag tag ; +union { +lf ; /* tag Lf */ +int +snoc_list br ; /* tag Br */ + +} alt ; +} * ntree ; + +(b) Here are the functions nlf and nbr: +ntree nlf( int lf ) { + +ntree t ; +t = malloc( sizeof( struct ntree_struct ) ) ; +if( t == NULL ) { + +printf( "nlf: no space\n" ) ; +abort( ) ; + +} +t->tag = Lf ; +t->alt.lf = lf ; +return t ; + +} + +ntree nbr( snoc_list br ) { + +ntree t ; +t = malloc( sizeof( struct ntree_struct ) ) ; +if( t == NULL ) { + +printf( "nbr: no space\n" ) ; +abort( ) ; + +} +t->tag = Br ; +t->alt.br = br ; +return t ; + +} + +(c) Here is the nprint function and its auxiliary function to print an element of + +the snoc list. + +void print_elem( void * e ) { + +ntree t = e ; +nprint( t ) ; + +} + +void nprint( ntree t ) { + +switch( t->tag ) { + +Revision: 6.38 + +(cid:0) + 385 + +case Lf : + +printf( "%d", t->alt.lf ) ; +break ; +case Br : + +printf( "(" ) ; +sprint( print_elem, t->alt.br ) ; +printf( ")" ) ; +break ; + +} + +} + +(d) Here is a main program to test the ntree data types and associated func- + +tions: + +int main( void ) { + +snoc_list l2 = snoc( snoc( snoc( NULL, + +nlf( 2 ) + +), + +nlf( 3 ) + +), + +nlf( 4 ) + +) ; + +snoc_list l1 = snoc( snoc( NULL, + +nlf( 1 ) + +), +nbr( l2 ) + +); + +ntree t1 = nbr( l1 ) ; +ntree t2 = nbr( NULL ) ; +nprint( t1 ) ; +printf( "\n" ) ; +nprint( t2 ) ; +printf( "\n" ) ; +return 0 ; + +} + +Answer to 8.15: + +(a) Here is the C interface snoclist.h for the snoc list module: + +#ifndef SNOC_LIST_H +#define SNOC_LIST_H +typedef struct snoc_struct * snoc_list ; + +extern snoc_list snoc( snoc_list head, void * tail ) ; + +extern snoc_list head( snoc_list l ) ; +extern void * tail( snoc_list l ) ; + +Revision: 6.38 + +(cid:0) + 386 + +AppendixA. Answerstoexercises + +extern void sprint( void (* print) ( void * ), snoc_list l ) ; +#endif /* SNOC_LIST_H */ + +Here is the corresponding C implementation snoclist.c for the snoc list +module: + +#include +#include +#include "snoclist.h" + +struct snoc_struct { + +void +* snoc_tail ; +struct snoc_struct * snoc_head ; + +} ; + +snoc_list snoc( snoc_list head, void * tail ) { + +snoc_list l = malloc( sizeof( struct snoc_struct ) ) ; +if( l == NULL ) { + +printf( "snoc: no space\n" ) ; +abort( ) ; + +} +l->snoc_head = head ; +l->snoc_tail = tail ; +return l ; + +} + +snoc_list head( snoc_list l ) { + +return l->snoc_head ; + +} + +void * tail( snoc_list l ) { + +return l->snoc_tail ; + +} + +void sprint( void (* print) ( void * ), snoc_list xs ) { + +if( xs != NULL ) { + +snoc_list ys = head( xs ) ; +if( ys != NULL ) { + +sprint( print, ys ) ; +printf( "," ) ; + +} +print( tail( xs ) ) ; + +} + +} + +(b) Here is the C interface ntree.h for the ntree data type and its functions. + +#ifndef NTREE_H +#define NTREE_H +typedef struct ntree_struct * ntree ; + +Revision: 6.38 + + 387 + +extern ntree nlf( int lf ) ; +extern ntree nbr( snoc_list br ) ; + +extern void nprint( ntree t ) ; +#endif /* NTREE_H */ + +Here is the implementation of the ntree module: + +#include +#include +#include "snoclist.h" +#include "ntree.h" + +typedef enum {Br, Lf} ntree_tag ; + +struct ntree_struct { + +ntree_tag tag ; +union { +int +lf ; /* tag Lf */ +snoc_list br ; /* tag Br */ + +} alt ; + +} ; + +ntree nlf( int lf ) { + +ntree t ; +t = malloc( sizeof( struct ntree_struct ) ) ; +if( t == NULL ) { + +printf( "nlf: no space\n" ) ; +abort( ) ; + +} +t->tag = Lf ; +t->alt.lf = lf ; +return t ; + +} + +ntree nbr( snoc_list br ) { + +ntree t ; +t = malloc( sizeof( struct ntree_struct ) ) ; +if( t == NULL ) { + +printf( "nbr: no space\n" ) ; +abort( ) ; + +} +t->tag = Br ; +t->alt.br = br ; +return t ; + +} + +void nprint( ntree t ) ; + +Revision: 6.38 + + 388 + +AppendixA. Answerstoexercises + +void print_elem( void * e ) { + +ntree t = e ; +nprint( t ) ; + +} + +void nprint( ntree t ) { + +switch( t->tag ) { +case Lf : + +printf( "%d", t->alt.lf ) ; +break ; +case Br : + +printf( "(" ) ; +sprint( print_elem, t->alt.br ) ; +printf( ")" ) ; +break ; + +} + +} + +(c) Here is a main program to test the modules: + +#include +#include "snoclist.h" +#include "ntree.h" + +int main( void ) { + +snoc_list l2 = snoc( snoc( snoc( NULL, + +nlf( 2 ) + +), + +nlf( 3 ) + +), + +nlf( 4 ) + +) ; + +snoc_list l1 = snoc( snoc( NULL, + +nlf( 1 ) + +), +nbr( l2 ) + +); + +ntree t1 = nbr( l1 ) ; +ntree t2 = nbr( NULL ) ; +nprint( t1 ) ; +printf( "\n" ) ; +nprint( t2 ) ; +printf( "\n" ) ; +return 0 ; + +} + +Revision: 6.38 + + 389 + +Answers to the exercises of Chapter 9 + +Answer to 9.1: The C preprocessor performs a textual substitution, so any oc- +currence of the identi(cid:2)ers WIDTH and HEIGHT would be replaced. This results +in troubles for the functions window_to_complex and draw_Mandelbrot, as +WIDTH and HEIGHT appear in their argument lists. The header of the function +window_to_complex is: + +complex window_to_complex( int X, int Y, int WIDTH, + +int HEIGHT, double x, double y, +double width, double height ) + +After substitution of WIDTH and HEIGHT it would read: + +complex window_to_complex( int X, int Y, int 100, + +int 100, double x, double y, +double width, double height ) + +This is not legal C. The same substitution would take place in the argument list of +draw_Mandelbrot. + +Answer to 9.3: The following two elements are needed: + +void (*draw_circle)( void *g, int x0, int y0, int r ) ; +void (*draw_ellipse)( void *g, int x0, int y0, int r, int dx ) ; + +Answer to 9.4: The SML data structure uses a type variable (cid:146)a . This type is re- +turned by the Open function and used by subsequent functions. The C data struc- +ture uses void * as replacement for polymorphic typing. The C compiler cannot +check whether the appropriate data structure is passed from the open-function to +the draw-functions (see Section 4.5). + +Answer to 9.6: The PostScript driver for the device independent graphics is: + +#include "PSdriver.h" +#include +#include + +typedef struct { +FILE *file ; + +} PSInfo ; + +void *PS_open( void *what ) { + +PSInfo *i = malloc( sizeof( PSInfo ) ) ; +char *filename = what ; +i->file = fopen( filename, "w" ) ; + +Revision: 1.25 + + AppendixA. Answerstoexercises + +390 + +} + +if( i->file == NULL ) { + +return NULL ; + +} +fprintf( i->file, "%%!PS\n" ) ; +return (void *) i ; + +void PS_draw_line(void *g, int x0, int y0, int x1, int y1) { + +PSInfo *i = g ; +fprintf( i->file, "newpath\n" ) ; +fprintf( i->file, "%d %d moveto\n", x0, y0 ) ; +fprintf( i->file, "%d %d lineto\n", x1, y1 ) ; +fprintf( i->file, "closepath\n" ) ; +fprintf( i->file, "stroke\n" ) ; + +} + +void PS_draw_box(void *g, int x0, int y0, int x1, int y1) { + +PSInfo *i = g ; +fprintf( i->file, "newpath\n" ) ; +fprintf( i->file, "%d %d moveto\n", x0, y0 ) ; +fprintf( i->file, "%d %d lineto\n", x0, y1 ) ; +fprintf( i->file, "%d %d lineto\n", x1, y1 ) ; +fprintf( i->file, "%d %d lineto\n", x1, y0 ) ; +fprintf( i->file, "%d %d lineto\n", x0, y0 ) ; +fprintf( i->file, "closepath\n" ) ; +fprintf( i->file, "stroke\n" ) ; + +} + +void PS_close( void *g ) { + +PSInfo *i = g ; +fprintf( i->file, "%%%%Eof\n" ) ; +fclose( i->file ) ; +free( i ) ; + +} + +graphics_driver PSDriver = { + +PS_open, +PS_draw_line, +PS_draw_box, +/*C other functions of the driver*/ +PS_close + +} ; + +Revision: 1.25 + + c(cid:0) + +1995,1996 Pieter Hartel & Henk Muller, all rights reserved. + +Appendix B + +A brief review of SML + +In this appendix we will present a brief overview of the salient features of SML +for the reader who is familiar with another functional programming language. We +cover just enough material to make the reader feel comfortable when reading our +book. We should point out that SML has more to offer than we use in this book; +the interested reader might wish to consult one of the many textbooks available on +programming in SML [15, 9, 16]. + +B.1 About the four main functional languages + +The most important functional languages to date are Lisp, SML, Miranda, and +Haskell. There are many small differences between these four languages and only +a few major differences. + +The main difference between Lisp and the other three is that Lisp is dynami- +cally typed, whereas the other three languages are statically typed. In a statically +typed language the compiler will reject expressions that are incorrectly typed; in a +dynamically typed languages such errors are detected at run time. + +The compilers for SML, Miranda, and Haskell will automatically infer the +types of all functions. In addition, Miranda and Haskell allow the programmer to +explicitly declare the type of a function. The compiler will check that the explicit +type declaration is consistent with type information as has been inferred. Explicit +type declarations are a useful form of documentation, which help the reader to un- +derstand the purpose of a function. The fact that this form of documentation can +be checked for consistency makes it also a reliable form of documentation. SML +unfortunately does not permit the explicit declaration of function types. Therefore +we have resorted to giving the type of each function in this book as a comment. +(Comments in SML are enclosed in the symbols (* and *)). + +The main difference between SML and Miranda on the one hand and Haskell +on the other hand is that the type system of Haskell provides proper support for +overloaded functions by means of the type class system. A function (or more ap- +propriately an operator) such as (cid:2) +is overloaded if it can be applied to arguments +(cid:6) , the operands +(or operands) of different types. For example, in the expression (cid:0) +are integers and, in the expression (cid:0) + +(cid:1) , the operands are reals. + +391 + +(cid:2) +(cid:16) +% +(cid:2) +(cid:2) +(cid:16) +(cid:0) + 392 + +AppendixB. AbriefreviewofSML + +The main difference between Lisp and SML on the one hand and Miranda and +Haskell on the other hand is that Lisp and SML are eager languages whereas Mi- +randa and Haskell are lazy languages. In an eager language, the argument to a +function is always evaluated before the function is called. In a lazy language, the +evaluation of an argument to a function may be postponed until the evaluation of +the argument is necessary. If the function does not actually use its argument, it +will never be evaluated, thus saving some execution time. The functions that we +use in this book work in an eager language. It would thus be possible to interpret +all our SML functions in Haskell or Miranda. + +The module systems of the four programming languages are all rather differ- +ent. SML has the most sophisticated module system. The module systems of +Haskell and Miranda are simpler but effective. Many different Lisp systems ex- +ists, with a wide variation of module systems, ranging from the primitive to the +sophisticated. + +Below we discuss the basic elements of a functional program, and describe the +particular features offered by SML. In its basic form, a module from a functional +program consists of a number of data type and function de(cid:2)nitions, and an ex- +pression to be evaluated. + +B.2 Functions, pattern matching, and integers + +All functional languages offer the possibility to de(cid:2)ne a function by giving its +name, a list of arguments and the function body. We give as an example the de(cid:2)ni- +tion of a function to calculate a binomial coef(cid:2)cient. The function has two integer +arguments and computes an integer result. We use the following equation to com- +pute the binomial coef(cid:2)cient, assuming that % + +: + +(cid:2)(cid:1) + +if + +otherwise + +Here is the SML function over which uses this equation. The type of the function +is given as a comment. It states that over has two integer arguments and that its +function result is also an integer. + +(* over : int -> int -> int *) +fun over n 0 = 1 + +| over n m = if n = m + +then 1 +else over (n-1) m + over (n-1) (m-1) ; + +A function de(cid:2)nition in SML is introduced by the keyword fun and terminated by +a semicolon ;. Layout is not signi(cid:2)cant in SML; in particular, there is no off side +rule as in Miranda and Haskell. The function name is over. The function name +is then followed by the names of the formal arguments. The function over has +two alternative de(cid:2)nitions, separated by the vertical bar |. The (cid:2)rst clause applies +when the second argument has the value 0. The second clause applies when the + +Revision: 6.18 + +(cid:11) +(cid:12) +(cid:11) +(cid:15) +(cid:0) +(cid:15) +(cid:12) +(cid:0) +(cid:6) +(cid:7) +(cid:8) +(cid:7) +(cid:9) +(cid:0) +(cid:14) +(cid:12) +(cid:0) +% +(cid:1) +(cid:12) +(cid:0) +(cid:15) +(cid:0) +(cid:15) +(cid:0) +(cid:0) +(cid:12) +(cid:1) +(cid:2) +(cid:0) +(cid:15) +(cid:0) +(cid:0) +(cid:12) +(cid:0) +(cid:0) +(cid:1) +(cid:14) + B.2. Functions, patternmatching, andintegers + +393 + +second argument, m, is not equal to 0. The two de(cid:2)ning clauses of the function +are distinguished by pattern matching on the argument(s). Clauses are tried top +down, and arguments are matched left to right. + +The function result of the (cid:2)rst clause of over is 1; that of the second clause is +determined by the conditional expression if . . . then . . . else . . . . If the values +of n and m are equal, the function result is also 1. +If n and m are unequal, two +recursive calls are made and the results are added. + +In most functional languages, parentheses serve to build expressions out of +groups of symbols and not to delineate function arguments. This explains why +the recursive call to the function over looks like this: + +over (n-1) (m-1) + +One might have expected it to look like this: + +over(n-1,m-1) + +This latter notation would be more consistent with common mathematical use of +parentheses to delineate function arguments. In SML, but also in Haskell and Mi- +randa, it is possible to enclose functional arguments in parentheses and to sepa- +rate the arguments by commas. With this notation, we can de(cid:2)ne a new function +to look like this (an identi(cid:2)er may contain an apostrophe (cid:146) as a legal char- +over(cid:146) +acter): + +(* over(cid:146) : int * int -> int *) +fun over(cid:146)(n,0) = 1 + +| over(cid:146)(n,m) = if n = m + +then 1 +else over(cid:146)(n-1,m) + over(cid:146)(n-1,m-1) ; + +The two arguments n and m are now treated as a tuple consisting of two integers. +This is indicated in the type of the function, which indicates that it expects one +argument of type (int * int). This notation is called the uncurried notation. In +the curried notation a function takes it arguments one by one. The curried notation +is commonly used in lazy languages such as Haskell or Miranda programs. It is +easy to mix the two notations inadvertently, but the compilers will discover such +errors because of the ensuing type mismatches. + +Haskell and Miranda do not distinguish between functions with arguments +and functions without arguments. However, SML does distinguish between the +two. A function without arguments is a value, which may be given a name using +the val declaration. The following de(cid:2)nes two values, over_4_3 and over_4_2. +Both are of type int: + +(* over_4_3,over_4_2 : int *) +val over_4_3 = over 4 3 ; +val over_4_2 = over 4 2 ; + +The results printed by the SML system are 4 and 6 respectively. + +Revision: 6.18 + + 394 + +AppendixB. AbriefreviewofSML + +B.3 Local function and value de(cid:2)nitions + +SML permits the de(cid:2)nition of local functions and values within an expression. Lo- +cal de(cid:2)nitions are often useful to avoid the recomputation of a value that is used +several times. In the function over de(cid:2)ned earlier, the expression n-1 appears +twice. This value can be computed just once by giving it a name in a local let +de(cid:2)nition: + +(* over : int -> int -> int *) +fun over n 0 = 1 + +| over n m = if n = m + +then 1 +else let + +in + +val k = n-1 + +over k m + over k (m-1) + +end ; + +The construct let . . . in . . . end represents a single expression with one or more +local de(cid:2)nitions. After the keyword let, any number of function and value def- +initions may appear, each introduced by the relevant keyword fun or val. The +let expressions of SML are more general than the where clauses of Miranda, be- +cause let expressions may be arbitrarily nested. Miranda’s where clauses apply +to function de(cid:2)nitions and can only be nested if the function de(cid:2)nitions are nested. +Haskell provides both facilities. + +B.4 Reals, booleans, strings, and lists + +The basic data types of SML are integers, reals, booleans, strings, and lists. In the +previous section we have only used integers; here we will de(cid:2)ne a function that +works on other data types to see how they could be used. The function locate +below is a polymorphic function of two arguments. The second argument is a +list of values of some polymorphic type (cid:146)a , in which the function locate will +be searching for an occurrence of the (cid:2)rst argument. In SML type variables are +written as (cid:146)a , (cid:146)b , and so on. In Haskell we would write a, b and in Miranda one +would use *, **, and so on. + +The (cid:2)rst argument of locate is of the same type (cid:146)a as the elements of the list. +If the element is found in the list, the boolean value true is returned, false oth- +erwise. The term ‘polymorphic’ stems from the fact that a polymorphic function +has really many forms; it adapts itself to the form of its actual argument. + +(* locate : (cid:146)a -> (cid:146)a list -> bool *) +fun locate a [] + += false + +| locate a (x::xs) = (a = x) orelse locate a xs ; + +The function locate uses pattern matching on the second argument. If this repre- +sents the empty list [], the function result is false. Otherwise, the list is deemed +to be non empty, with a head element x and tail xs. The double colon :: is the + +Revision: 6.18 + + B.5. Typesynonymsandalgebraicdatatypes + +395 + +pattern symbol for lists. In Haskell and Miranda : is the pattern symbol for lists +and :: introduces a type. + +The operator orelse in SML is the logical disjunction. + +It evaluates its left +operand (cid:2)rst. If this yields true, then it does not evaluate the right operand. If +the leftmost operand evaluates to false, then the rightmost operand of orelse +is evaluated. The orelse operator is said to have short-circuit semantics. The +orelse operator has two companions: the andalso operator for the logical con- +junction and the conditional construct if . . . then . . . else. All three have short- +circuit semantics. These are the only exceptions to the rule that SML functions and +operators always evaluate their arguments (cid:2)rst. + +The function locate is polymorphic in the type of the element to be looked + +up in the list. Therefore the following are all valid uses of locate: +(* locate_nil,locate_bool,locate_int : bool *) +(* locate_char,locate_string,locate_real : bool *) += locate 2 [] ; +val locate_nil += locate true [false,false] ; +val locate_bool += locate 2 [1,2,3] ; +val locate_int +val locate_char += locate "x" ["a","b","c","d"] ; +val locate_string = locate "foo" ["foo","bar"] ; += locate 3.14 [0.0, 6.02E23] ; +val locate_real + +The notation [1,2,3] is shorthand for 1::(2::(3::[])), where [] is the +empty list and :: is the concatenation of a new element to the head of a list. + +SML does not offer characters as a basic type. Instead, it provides character +strings enclosed in double quotes ". By convention, a string with a single char- +acter is used where one would use a character in Haskell or Miranda. A further +property of SML is that a string is not a list of characters but a separate data type. +The functions explode and implode convert between an SML string and a list of +single element strings. The two equations below are both true: + +(* true_explode,true_implode : bool *) +val true_explode = (explode "foo" = ["f","o","o"]) ; +val true_implode = (implode ["b","a","r"] = "bar") ; + +B.5 Type synonyms and algebraic data types + +User de(cid:2)ned data types are introduced either by type synonyms or by algebraic +data type declarations. A type synonym gives a name to an existing type. For +example, a pair of two integers has type int * int. Instead of spelling this out +each time we use this type, we can give it a name, say int_pair, and use the +name instead of int * int. This is how we would de(cid:2)ne the type synonym in +SML: + +type int_pair = int * int ; + +The keyword type indicates that a type synonym is going to be de(cid:2)ned. This is +the same as in Haskell. In Miranda the symbol == introduces a type synonym. + +Revision: 6.18 + + 396 + +AppendixB. AbriefreviewofSML + +New types can be created using a algebraic data type declaration. Here is how + +a binary tree would be de(cid:2)ned with integers at the leaf nodes: + +datatype int_tree = Int_Branch of int_tree * int_tree + +| Int_Leaf of int ; + +The keyword datatype announces the declaration of an algebraic data type. +Here the identi(cid:2)er Int_Branch is a data constructor, which can be viewed as a +function. This function should be applied to a tuple consisting of a left subtree +and a right subtree. Both subtrees are values of type int_tree. The identi(cid:2)er +Int_Leaf is again a data constructor, this time taking an integer value as an ar- +gument. SML does not permit curried constructors; Haskell and Miranda allow +both curried and uncurried constructors but the former are more common. Here +is the usual curried Miranda notation: + +num_tree ::= Num_Branch num_tree num_tree | + +Num_Leaf num ; + +Let us now use the int_tree data type de(cid:2)nition to create a sample trees in SML: + +(* sample_int_tree : int_tree *) +val sample_int_tree + += Int_Branch(Int_Leaf 1, + +A graphical representation of this tree would be as follows: + +Int_Branch(Int_Leaf 2,Int_Leaf 3)) ; + +1 + +2 + +3 + +The function walk_add, as given below, traverses a tree, adding the numbers +stored in the leaves. The function de(cid:2)nition uses pattern matching on the con- +structors of the data structure: + +(* walk_add : int_tree -> int *) +fun walk_add (Int_Branch(left,right)) + += walk_add left + walk_add right + +| walk_add (Int_Leaf data) + += data ; + +The type of walk_add states that the function has one argument with values of +type int_tree and that the function result is of the type int. The de(cid:2)nition of +walk_add has two clauses. The (cid:2)rst clause applies when an interior node is en- +countered. As interior nodes do not contain data, the function result returned by +this clause is the sum of the results from the left and right branch. The function +result returned by the second clause is the data stored in a leaf node. + +Revision: 6.18 + + B.6. Higherorderfunctions + +397 + +The value add_int_main below represents walk_add applied to our sample + +tree of integers: + +(* add_int_main : int *) +val add_int_main = walk_add sample_int_tree ; + +The value computed by add_int_main is 6. + +B.6 Higher order functions + +The walk_add function from the previous section is a combination of two things: +it embodies a tree traversal algorithm and it encodes a particular operation (addi- +tion) over the tree. These two issues can be separated to make the code usable in +a wider context. This separation requires the introduction of a polymorphic data +type tree and a pure tree walk function poly_walk. Here is the polymorphic +tree data type: + +datatype (cid:146)a tree = Branch of (cid:146)a tree * (cid:146)a tree + +| Leaf of (cid:146)a ; + +The tree data type has a type parameter, indicated by the type variable (cid:146)a , for +which any type may be substituted. Our sample tree can be encoded using the +tree data type as follows: + +(* sample_poly_tree : int tree *) +val sample_poly_tree += Branch(Leaf 1, + +Branch(Leaf 2,Leaf 3)) ; + +The type of sample_poly_tree is int tree, which indicates that we have in- +stantiated the polymorphic tree data type to a concrete tree with data of type int +at the leaves. + +Not only the data type tree but also the poly_walk function carries a param- +eter. This parameter (called comb below) represents the binary function applied +when results of the left and right branch are combined. + +(* poly_walk : ((cid:146)a->(cid:146)a->(cid:146)a) +fun poly_walk comb (Branch(left,right)) + +-> (cid:146)a tree -> (cid:146)a *) + += comb (poly_walk comb left) (poly_walk comb right) + +| poly_walk comb (Leaf data) + += data ; + +The type of poly_walk indicates that the comb function has type (cid:146)a->(cid:146)a->(cid:146)a +. +It should produce a result of the same type as that of its two arguments. A value +of that same type should be stored in the tree, and a value of this type will also be +produced as the (cid:2)nal result of poly_walk. + +The value poly_add_int_main below applies the general poly_walk func- +tion to the concrete binary tree sample_poly_tree, which has integers at its leaf +nodes. Here add is the curried version of the addition operator: + +(* poly_add_int_main : int *) +val poly_add_int_main + +Revision: 6.18 + + 398 + +AppendixB. AbriefreviewofSML + += let + +in + +fun add x y = x+y + +poly_walk add sample_poly_tree + +end ; + +The following identity relates the two tree walk functions that have been de(cid:2)ned +thus far: + +poly_walk add a_tree (cid:0) walk_add a_tree + +It is possible to prove that this equality holds for all (cid:2)nite trees by induction on the +structure of the argument a_tree. + +Here is another tree built using the tree data type. This time, we have strings + +at the leaves: + +(* string_poly_tree : string tree *) +val string_poly_tree + += Branch(Leaf "Good", + +Branch(Leaf "Bad",Leaf "Ugly")) ; + +A graphical representation of this tree would be: + +(cid:148)Good(cid:148) + +(cid:148)Bad(cid:148) + +(cid:148)Ugly(cid:148) + +A function suitable to traverse this tree would be one that concatenates the strings +found at the leaves. To make the output look pretty it also inserts a space between +the words found in the tree: +(* film : string *) +val film + += let + +in + +fun concat x y = x ˆ " " ˆ y + +poly_walk concat string_poly_tree + +end ; + +The string value of film is thus "Good Bad Ugly". Polymorphism has helped +to produce two different functions with code reuse. + +B.7 Modules + +A module system serves to gather related type, data type, function, and value dec- +larations together so that the collection of these items can be stored, used, and + +Revision: 6.18 + + B.7. Modules + +399 + +manipulated as a unit. The module system of SML is one of the most advanced +available to date in any programming language. We will discuss here the basics +of the module system. The most striking feature of the module system is its sys- +tematic design. An SML structure is a collection of types, data types, functions, +and values. A signature basically gives just the types of these items in a structure. +The relation between structures and signatures is roughly the same as the relation +between types on the one hand and functions and values on the other. Put differ- +ently, signatures (types) are an abstraction of structures (values and functions). + +Consider the following structure as an example. It collects an extended poly- +morphic tree data type tree, an empty tree empty, and an extended tree walk +function walk into a structure called Tree. (The extensions were made to create a +more interesting example, not because of limitations of the module mechanism.) + +structure Tree = struct + +datatype (cid:146)a tree = Branch of (cid:146)a tree * (cid:146)a tree +| Leaf of (cid:146)a +| Empty ; + +(* empty : (cid:146)a tree *) +val empty = Empty ; + +(* walk : ((cid:146)a->(cid:146)a->(cid:146)a) +fun walk comb default (Branch(left,right)) + +-> (cid:146)a -> (cid:146)a tree -> (cid:146)a *) + += comb (walk comb default left) + +(walk comb default right) + +| walk comb default (Leaf data) + += data + +| walk comb default (Empty) + += default + +end ; + +The keyword structure announces that the declaration of a structure follows. +This is similar to the use of the keywords fun and val. The keyword struct +is paired with the keyword end. These two keywords delineate the declaration +of the three components of the structure. The declarations of the components of +the structure (the data type tree, the value empty, and the function walk) are +created according to the normal rules for declaring such items. + +With the structure declaration in place, we can create a sample tree by qualify- +ing each identi(cid:2)er from the structure by the name of the structure. This time, we +will create a tree of reals as an example: + +(* sample_real_tree : real Tree.tree *) +val sample_real_tree + += Tree.Branch(Tree.Leaf 1.0, + +It is necessary to indicate from which structure a particular component emerges, + +Tree.Branch(Tree.Leaf 2.0,Tree.Leaf 3.0)); + +Revision: 6.18 + + 400 + +AppendixB. AbriefreviewofSML + +because it is possible to use the same component names in different structures. As +a convenient shorthand, we can open the structure Tree and use its component +names unquali(cid:2)ed as follows: + +(* sample_real_tree : real Tree.tree *) +val sample_real_tree + += let + +in + +open Tree + +Branch(Leaf 1.0, + +Branch(Leaf 2.0,Leaf 3.0)) + +end ; + +Traversing the nodes of the sample tree and adding the data values is achieved by +the following code: + +(* add_real_main : real *) +val add_real_main + += let + +in + +fun add x y = x+y + +Tree.walk add 0.0 sample_real_tree + +end ; + +The walk function is the only component used from the structure. + +The signature of a structure is the interface to the structure. Here is the signa- + +ture of the Tree structure: + +signature TREE = sig + +datatype (cid:146)a tree = Branch of (cid:146)a tree * (cid:146)a tree +| Leaf of (cid:146)a +| Empty ; + +val empty : (cid:146)a tree ; +val walk : ((cid:146)a->(cid:146)a->(cid:146)a) + +end ; + +-> (cid:146)a -> (cid:146)a tree -> (cid:146)a + +As with the structure, function, and value declarations, a keyword, signature, +indicates that a signature declaration follows. The contents of the signature decla- +ration are enclosed between the keywords sig and end. + +The signature TREE shows that the structure Tree has three components. The +(cid:2)rst is a data type named tree. The second component is a value empty, and the +third is a function that takes three arguments (a function, a value, and a tree). All +components are polymorphic in a type parameter (cid:146)a . + +We could now create a new structure, say My_Tree, which explicitly declares + +the structure to have the signature TREE given above: + +structure My_Tree : TREE = Tree ; + +The signature of the structure My_Tree is the same as that inferred for the struc- +ture Tree. Thus nothing is to be gained by introducing this new structure. A more +interesting use of signatures is to hide some of the components of a structure. We +could de(cid:2)ne a new structure, say Non_Empty_Tree, which does not provide the + +Revision: 6.18 + + B.8. Libraries + +401 + +value empty. This effectively restricts the use that can be made of components +of a structure. Such restrictions are useful to prevent auxiliary types, data types, +functions, and values from being used outside the structure. + +signature NON_EMPTY_TREE = sig + +datatype (cid:146)a tree = Branch of (cid:146)a tree * (cid:146)a tree +| Leaf of (cid:146)a +| Empty ; + +val walk : ((cid:146)a->(cid:146)a->(cid:146)a) + +-> (cid:146)a -> (cid:146)a tree -> (cid:146)a + +end ; + +structure Non_Empty_Tree : NON_EMPTY_TREE = Tree ; + +It is even possible to parametrise structures using so-called functors. These more +advanced features are not used in the book, so we do not discuss them here. + +B.8 Libraries + +The SML language provides a set of prede(cid:2)ned operators and functions. Fur- +thermore, different implementations of SML may each offer an extensive set of li- +braries. We have made as little use as possible of the wealth of library functions +that are available to the SML programmer. Firstly, having to know about a min- +imal core of SML and its libraries makes it easier to concentrate on learning C. +Secondly, by using only a few library functions the book is only loosely tied to a +particular implementation of SML. + +We use a small number of prede(cid:2)ned operators and functions and only four +functions from the SML/NJ array library. In addition, we have de(cid:2)ned a number +of functions of our own which are similar to the SML library functions of most +implementations. + +Here are the prede(cid:2)ned operators and their types as they are being used + +throughout the book: + +type +int * int -> int +real * real -> real + +operator ++, -, *, div, mod ++, -, *, / +<, <=, <>, =, >=, > int * int -> bool +<, <=, <>, =, >=, > real * real -> bool +ˆ +size +ord +chr +:: +@ + +string * string -> string +string -> int +string -> int +int -> string +(cid:146)a * (cid:146)a list -> (cid:146)a list +(cid:146)a list * (cid:146)a list -> (cid:146)a list + +The list processing functions below are similar to those found in Haskell and Mi- +randa. The SML versions that we use are not from a standard library. Instead, they + +Revision: 6.18 + + 402 + +AppendixB. AbriefreviewofSML + +have been de(cid:2)ned in the text and are used in many places. Several of these func- +tions are used in a speci(cid:2)c monomorphic context. We only give the polymorphic +forms here. The name and type of each function is accompanied by the number +of the page where the function is de(cid:2)ned and described. The list is in alphabetical +order. + +((cid:146)a -> (cid:146)b -> (cid:146)a) -> (cid:146)a -> (cid:146)b list -> (cid:146)a +((cid:146)b -> (cid:146)a -> (cid:146)a) -> (cid:146)a -> (cid:146)b list -> (cid:146)a +(cid:146)a list -> (cid:146)a + +function type +(--) +int * int -> int list +append (cid:146)a list -> (cid:146)a list -> (cid:146)a list +filter ((cid:146)a -> bool) -> (cid:146)a list -> (cid:146)a list +foldl +foldr +head +length (cid:146)a list -> int +map +nth +prod +sum +tail + +((cid:146)a -> (cid:146)b) -> (cid:146)a list -> (cid:146)b list +(cid:146)a list -> int -> (cid:146)a +int list -> int +int list -> int +(cid:146)a list -> (cid:146)a list + +page number +80 +186 +92 +80 +86 +183 +185 +89 +186 +81 +89 +183 + +Here are the four array functions that we use from the SML/NJ array module. +They are similar to the array processing functions from Haskell. + +function +array +length +sub +tabulate int * (int->(cid:146)a) -> (cid:146)a array + +type +int * (cid:146)a -> (cid:146)a array +(cid:146)a array -> int +(cid:146)a array * int -> (cid:146)a + +page number +136 +137 +137 +137 + +We add to this repertoire of basic array functions three further generally useful +functions: + +type + +function +concatenate (cid:146)a array * (cid:146)a array -> (cid:146)a array +slice +upd + +(cid:146)a array * int * int -> (cid:146)a array +(cid:146)a array * int * (cid:146)a -> (cid:146)a array + +page number +138 +138 +137 + +This concludes the presentation of the relatively small core of SML that we use in +the book to study programming in C. + +Revision: 6.8 + + c(cid:0) + +1995,1996 Pieter Hartel & Henk Muller, all rights reserved. + +Appendix C + +Standard Libraries + +C offers a rich variety of library functions. Some of these functions are used so +often that a short reference is indispensable to the reader of this book. This chapter +provides such a reference. For the complete set of standard libraries one has to +consult the C reference manual [7]. + +Besides the standard libraries many system calls are usually directly available to +the C programmer. As an example, functions for accessing (cid:2)les under UNIX, Win- +dows, or Macintosh and usually also functions to manage processes or network +connections are readily available. + +In addition to these, there are many other libraries available. We have seen a +small part of the X-window library in Chapter 9. Other libraries that exist are for +example cryptographic libraries [11], and numerical libraries [10]. For all these, we +refer the reader to the appropriate documentation. + +The standard library consists of a collection of modules. Each of these modules +requires a different interface (cid:2)le to be loaded. Most computer systems will not +require you to specify that you wish to link any of the libraries, with the excep- +tion of the mathematics library under UNIX. Below, (cid:2)ve modules are explained in +detail: I/O, strings, character types, mathematics, and utilities. The (cid:2)nal section +summarises the purpose of the modules that we have not described. + +C.1 Standard I/O + +The standard I/O library provides functions that allow the programmer to per- +form input and output operations. Input and output can be performed on (cid:2)les, +which have a type FILE *. There are three standard (cid:2)le descriptors: stdin, +which is the standard input of the programming, normally from the keyboard; +stdout, the standard output of the program, normally directed to the screen; and +stderr, the (cid:2)le to write error messages, normally directed to the screen. +To use any of the I/O facilities, the (cid:2)le stdio.h has to be included: + +#include + +The most important data and functions of this library are listed below. A complete +reference is given in the C reference manual [7]: + +403 + + 404 + +AppendixC. Standard Libraries + +FILE Is a type that stores the information related to a (cid:2)le. Normally only refer- +ences to this types are passed, which are thus of type FILE *. An entity of +type FILE * is referred to as a (cid:2)le pointer or a stream. + +FILE *stdin Is a global identi(cid:2)er referring to the standard input stream. +FILE *stdout Is a global identi(cid:2)er referring to the standard output stream. +FILE *stderr Is a global identi(cid:2)er referring to the standard error stream. +void putchar( char c ) Puts a character on the standard output stream. +void printf( char *format, ... ) Prints its arguments on the standard +output stream. The (cid:2)rst argument is the format string, which speci(cid:2)es how +the other parameters are printed. The format string is copied onto the out- +put, with the exception of % speci(cid:2)ers. Whenever a % is encountered, one of +the arguments is formatted and printed. For example, a %d indicates an in- +teger argument, %f a (cid:3)oating point number, %s a string, %c a character, and +%p a pointer. + +int getchar( void ) Reads one character from the standard input. It returns +this character as an integer, or, if there are no more characters, the special +value EOF (End Of File). Note that EOF is an integer which cannot be repre- +sented as a character. + +int scanf( char *format, ... ) Reads values from the standard input +stream. The (cid:2)rst argument is a string that speci(cid:2)es what types of values to +read. The format of the string is similar to that of printf: %d speci(cid:2)es read- +ing an integer, %f a (cid:3)oating point number, and so on. The subsequent pa- +rameters must be pointers to variables with the appropriate type: int for %d, +char [] for %s, and so on. Types are not checked; therefore, accidentally +forgetting an & may have disastrous results. It is particularly important to +notice the difference between the formats %f and %lf. The (cid:2)rst one expects +a pointer to a float, the second expects a pointer to a double. You will +probably need the latter one. +The function scanf will read through the input stream, matching the input +with the formats speci(cid:2)ed. When a format is successfully matched, the re- +sulting value is stored via the associated pointer. If a match fails, then scanf +will give up and return, leaving the input positioned at the (cid:2)rst unrecog- +nised character. The return value of scanf equals the number of items that +were matched and stored. When the input stream is empty, EOF will be re- +turned. + +FILE *fopen( char *filename, char *mode ) Creates a (cid:2)le descriptor +that is associated with a (cid:2)le of your (cid:2)le system. The (cid:2)rst argument speci- +(cid:2)es the (cid:2)lename, the second the mode. Two frequently used modes are "r" +(opens the (cid:2)le for reading, you can use it with functions like scanf) and "w" +(opens the (cid:2)le for writing). If the (cid:2)le cannot be opened, a NULL pointer is re- +turned. + +void fprintf( FILE *out, char *format, ... ) Is like printf, but +the (cid:2)rst argument speci(cid:2)es on which (cid:2)le to print. The (cid:2)le can be one of +stdout, stderr, or any (cid:2)le opened with fopen. + +void sprintf( char *out, char *format, ... ) Is like printf, but +the (cid:2)rst argument speci(cid:2)es an array of characters where the output is to be + +Revision: 6.8 + + C.2. Strings + +405 + +stored. The array must be large enough to hold the output, no checking is +performed. + +void putc( char c, FILE *out ) Is like putchar, but on a speci(cid:2)c (cid:2)le. +int fscanf( FILE *in, char *format, ... ) Is like scanf, but scans + +from a speci(cid:2)c (cid:2)le. + +int sscanf( char *in, char *format, ... ) Is like scanf, but scans + +from a string. + +int getc( FILE *in ) Is like getchar, but from a speci(cid:2)c (cid:2)le. + +An important note: the functions putchar, getchar, getc, and putc are usu- +ally implemented with macros. The macro call semantics (Section 8.1.5) can cause +strange results when the arguments of these macros have a side effect. Unexpected +results can be avoided by using fputc and fgetc instead. + +C.2 Strings + +A string is represented as an array of characters (see also Section 5.5). To manipu- +late these arrays of characters, a string library is provided. To use this library, the +(cid:2)le string.h must be included: + +#include + +The most important functions of this library are: + +int strlen( char *string ) Returns the length of a string. +char *strncpy( char *out, char *in, int n ) Copies a string. The +third argument limits the number of characters that will be copied. The (cid:2)rst +argument is the destination array, the second the source array. + +char *strcpy( char *out, char *in ) Is like strncpy, but has no safe- + +guard against copying too many characters. + +char *strdup( char *string ) Allocates heap space using malloc to +hold a copy of the string and copies the string into it. If no space is available, +a NULL pointer is returned. When the string is no longer needed it should +be destroyed using free. + +char *strncat( char *out, char *in, int n ) Appends a string to +an existing string. The third argument limits the number of characters that +will be appended. The (cid:2)rst argument should contain the pre(cid:2)x of the string +and will contain the concatenated string when the function returns. + +char *strcat( char *out, char *in ) Is like strncat, but has no safe- + +guard against copying too many characters. + +int strcmp( char *s, char *t ) Performs a relational operation on two +The functions returns a negative number (if s < t), zero (if + +strings. +s == t), or a positive number (if s > t). + +int strncmp( char *s, char *t, int n ) Is like strcmp but it com- +pares at most n characters. If the strings are equal up to the n-th character, 0 +is returned. + +Revision: 6.8 + + 406 + +AppendixC. Standard Libraries + +char *strchr( char *s, char c ) Finds the (cid:2)rst occurrence of the char- +acter c in the string pointed to by s. A pointer to his (cid:2)rst occurrence is re- +turned. If c does not occur in s the NULL pointer is returned. + +char *strstr( char *s, char *t ) Finds the (cid:2)rst occurrence of + +the +string t in the string pointed to by s. A pointer to his (cid:2)rst occurrence is re- +turned. If t does not occur in s the NULL pointer is returned. + +Apart from these operations on (cid:146)\0(cid:146) +terminated character strings, there is a series +of functions that operate on blocks of memory. These functions treat the NULL- +character as any other character. The length of the block of memory must be +passed to each of these functions. + +void *memcpy( void *in, void *out, int n ) Is like strncpy. +void *memmove( void *in, void *out, int n ) Is like memcpy, but + +also works if in and out are overlapping parts of the same array (aliases). + +void *memchr( void *s, char c, int n ) Is like strchr. +int memcmp( void *s, void *t, int n ) Is like strncmp. +void *memset( void *in, int c, int n ) Fills the (cid:2)rst n bytes of in + +with the value c. + +C.3 Character classes + +The representation of characters may differ from one machine to another. To write +portable programs, the character class library provides predicates that yield true if +a character belongs to a certain class. The predicates can be used after including +the (cid:2)le ctype.h. + +#include + +The functions available in this library are: + +bool isdigit(char c) Tests if c is a digit. +bool isalpha(char c) Tests if c is a letter. +bool isupper(char c) Tests if c is an uppercase letter. +bool islower(char c) Tests if c is a lowercase letter. +bool isalnum(char c) Tests if c is a letter or a digit. +bool isxdigit(char c) Tests if c is a hexadecimal digit. +bool isspace(char c) Tests if c is a white space. +bool isprint(char c) Tests if c is a printable character. +bool isgraph(char c) Tests if c is a printable character but not a space. +bool ispunct(char c) Tests if c is a printable character but not a space, letter + +or digit. + +bool iscntrl(char c) Tests if c is a control character. +char toupper(char c) Converts c to an uppercase letter. +char tolower(char c) Converts c to a lowercase letter. + +Revision: 6.8 + + C.4. Mathematics + +C.4 Mathematics + +407 + +The mathematics library provides a number of general mathematical functions. +More specialised functions and numerical algorithms are provided by other li- +braries. It is essential to import the (cid:2)le math.h; the compiler might not warn you +if it is not included, but the functions will return random results. + +#include + +The functions available in this library are: + +double sin( double rad ) Calculates the sine of an angle. + +The angle + +should be in radians. + +double cos( double rad ) Calculates the cosine of an angle +double tan( double rad ) Calculates the tangent of an angle. +double asin( double x ) Calculates the arc sine of x. +double acos( double x ) Calculates the arc cosine of x. +double atan( double x ) Calculates the arc tangent of x. +double atan2( double x, double y ) Calculates the arc tangent of y/x. + +(A proper result is returned when x is 0.) + +double sinh( double rad ) Calculates the hyperbolic sine of x. +double cosh( double rad ) Calculates the hyperbolic cosine of x. +double tanh( double rad ) Calculates the hyperbolic tangent of x. +double exp( double x ) Calculates the exponential function of a number, + +(cid:0) . + +double log( double x ) Calculates the base (cid:0) (natural) logarithm of x. +double log10( double x ) Calculates the base 10 logarithm of x. +double pow( double x, double p ) Calculates x to the power p, (cid:8) +double sqrt( double x ) Calculates the square root of x, (cid:0) +double ceil( double x ) Calculate (cid:0) + +. +The function returns a double, not an int. It does not perform a coercion, +but it only rounds a (cid:3)oating point number. + +(cid:8)(cid:2)(cid:1) , the smallest integer not less than (cid:8) + +(cid:1) . + +. + +double floor( double x ) Calculate (cid:0) + +(cid:8)(cid:2)(cid:1) , the largest integer not greater + +than (cid:8) + +. + +double fabs( double x ) Returns the absolute value of x, +double ldexp( double x, int n ) Returns (cid:8) + +. +(cid:4) as a (cid:3)oating point num- + +ber. + +double frexp( double x, int * n ) Splits x into a fraction (cid:0) + +and a +(cid:0) . The fraction is the re- + +power of 2, (cid:12) +turn value of frexp and the power is assigned to *n. + +, such that (cid:8) + +(cid:1) and (cid:0) + +double modf( double x, double *i ) Takes a double, and splits it into its +integer and fractional part. The integer part is returned via i, the fractional +part is the return value of the function. + +double fmod( double x, double y ) Calculates x modulo y. + +Revision: 6.8 + +(cid:0) +(cid:8) +(cid:29) +(cid:8) +(cid:29) +(cid:6) +(cid:0) +(cid:0) +(cid:6) +(cid:1) +(cid:6) +(cid:11) +(cid:0) +(cid:10) + 408 + +AppendixC. Standard Libraries + +C.5 Variable argument lists + +The include (cid:2)le stdarg.h provides the facilities needed to work with variable +argument lists. This is how to include it into a module: + +#include + +Examples of functions that are implemented using this facility are printf and +scanf. A function using the variable argument list facility must have at least one +proper argument. The last proper argument must be followed by ellipses in the +prototype. Here is an example: + +void printf( char *format, ... ) ; + +The variable argument list module provides the following type and macro de(cid:2)ni- +tions: + +va_list This is the type of the data structure that provides access to the variable +arguments. A variable of type va_list must be declared in each function +using variable argument lists. + +va_start( va_list ap, (cid:8) ) The va_start macro must be called once be- +fore processing of the variable argument list begins. The variable (cid:8) should be +the last proper argument before the ellipses (...) in the function prototype. +In the case of printf above the (cid:8) would be format. + +(cid:1) va_arg( va_list ap, (cid:1) ) The va_arg macro will deliver the next item +from the argument list. This value has type (cid:1) . Each call to va_arg advances +to the next argument, until the argument list is exhausted. + +va_end( va_list ap ) The va_end macro terminates processing of the argu- +ment list. It should be called once before a function using the variable argu- +ment facility terminates. + +C.6 Miscellaneous + +The utility library is a collection of miscellaneous routines that did not (cid:2)t any- +where else. The utility library can be used by including stdlib.h: + +#include + +This module contains a large number of functions. We discuss only the most im- +portant functions below: + +int abs( int x ) Returns the absolute value of an integer. +int atoi( char *string ) Converts a string to an integer (the name stands + +for ascii to integer): atoi( "123" ) is 123. + +double atof( char *string ) Converts a string to a (cid:3)oating point number. +void *calloc( int x, int y ) Allocates heap space: suf(cid:2)cient space is +allocated to hold x cells of size y. All space is initialised to 0. This +function returns NULL if it cannot allocate suf(cid:2)cient space. You can use +sizeof to (cid:2)nd out how many bytes a certain type needs. +The call +calloc( 4, sizeof( int ) ) will return a pointer to an area of store +large enough to store 4 integers. + +Revision: 6.8 + + C.7. Othermodules + +409 + +void *malloc( int x ) Allocates x bytes of heap space. +void free( void *ptr ) Frees a previously allocated block of heap space. +void abort( void ) Stops the execution of the program immediately and +dramatically. It might invoke a debugger; or leave a dump for post mortem +examination. This function is used to terminate a program in case of a sus- +pected programming error. + +void exit( int status ) Stops the program gracefully. + +The value of +status is known as the exit status of the program. It signals whether the +program has successfully accomplished its task. Zero indicates success, any +non null value means a kind of failure (it is up to the programmer to specify +and document which value indicates which failure). If the program termi- +nates because main returns, the exit status is the value returned by main. + +C.7 Other modules + +There are 6 more modules in the C standard library. Each of these modules has an +associated include (cid:2)le and a number of library functions. Below we give a brief +description of each of these modules. + +Diagnostics, include (cid:2)le assert.h. This module allows the programmer to +verify that certain conditions are met (consistency check), the program is +aborted if the condition fails. + +Non local jumps, include (cid:2)le setjmp.h. A non local jump ‘returns’ from a num- +ber of nested function calls all at once and continues at a predetermined +place somewhere else in the program. + +Signals, include (cid:2)le signal.h. Signals are similar to SML exceptions. Signals +can be caught and sent. The system may send signals to indicate that some- +thing went wrong, for example a reference through a dangling pointer. +Date and Time, include (cid:2)le time.h. These are functions to (cid:2)nd out what time it + +is, and to convert time and date information into strings. + +Integer limits, include (cid:2)le limits.h. This module de(cid:2)nes constants that denote + +the maximum values that variables of type int, char, and so on, can take. + +Floating point limits, include (cid:2)le float.h. This module de(cid:2)nes constants that +denote the maximum (cid:3)oating point number that can be represented, the +number of bits in the mantissa and exponent, and so on. + +Revision: 6.8 + + 410 + +AppendixC. Standard Libraries + +Revision: 6.8 + + c(cid:0) + +1995,1996 Pieter Hartel & Henk Muller, all rights reserved. + +Appendix D + +ISO-C syntax diagrams + +This chapter summarises the complete syntax of ISO-C using railroad diagrams. A +railroad diagram has a name, a beginning at the top left hand side and an end at +the top right hand side. A diagram is read starting from the beginning and follow- +ing the lines and arcs to the end. Similar to what real trains on real rail roads can +do, you must always follow smooth corners and never take a sharp turn. + +On your way through a rail road diagram, you will encounter various sym- +bols. There are two kinds of symbols. A symbol in a circle or an oval stands for +itself. This is called a terminal symbol. Such a symbol represents text that may be +typed as part of a syntactically correct C program. A symbol in a rectangular box +is the name of another rail road diagram. This is a non-terminal symbol. To (cid:2)nd out +what such a symbol stands for you must lookup the corresponding diagram. Rail- +road diagrams can be recursive, when a non terminal is referring to the present +diagram. + +The rail road diagrams can be used for two purposes. The (cid:2)rst is to check that +a given C program uses the correct syntax. This should be done by starting at +the (cid:2)rst diagram (translation(cid:1)unit), and trying to (cid:2)nd a path through the diagrams +such that all symbols in the program are matched to symbols found on the way. + +Railroad diagrams are also useful as a reminder of what the syntax exactly +looks like. A path through the diagrams corresponds to an ordering on the sym- +bols that you may use. For example if you what to know what a for-statement +looks like, you should look up the diagram called statement, (cid:2)nd the keyword +for, and follow a path to the end of the diagram to see what you may write to +create a for-statement. Note that the railroad diagrams only describe the syntax +of the language. A syntactically correct program is not necessarily accepted by the +compiler as it may contain semantic errors (for example an illegal combination of +types). + +The diagrams that represent the ISO-C syntax are ordered in a top down fash- +ion. We explain a few diagrams in some detail to help you (cid:2)nd out for yourself +how to work with them. Let us study what a program or translation(cid:1)unit may look +like. + +(cid:1)(cid:3)(cid:2) + +??? + +411 + +(cid:0) +(cid:4) + 412 + +AppendixD. ISO-Csyntaxdiagrams + +The interpretation of this diagram is as follows: a translation(cid:1)unit can be either a +function(cid:1)de(cid:2)nition or a declaration, optionally followed by another function(cid:1)de(cid:2)nition +or declaration, and so on. It is thus possible to give an arbitrary number of either +function(cid:1)de(cid:2)nition or declaration. There must be at least one of either. + +Now that we know what the two main components of a program are, we + +should like to know more about each of them. Their de(cid:2)nitions are: + +(cid:1)(cid:3)(cid:2) + +??? + +??? + +As an example to show how the railroad diagram applies to a C constant declara- +tion, consider the following: + +const double eps=0.001, delta=0.0001 ; + +The words const double are matched by the diagram declaration(cid:1)speci(cid:2)ers (via +type(cid:1)speci(cid:2)er and type(cid:1)quali(cid:2)er). We then take the road to the lower part of declara- +tion, where eps matches declarator, we take the road to the =, where the equal sign +matches, the constant 0.001 matches initializer. The comma brings us back at the +declarator, which matches delta, and so on. + +??? + +(cid:1)(cid:3)(cid:2) + +??? + +??? + +The type(cid:1)quali(cid:2)er diagram shows that we have not explained everything there +is to know about C, because it shows a new keyword volatile. We are not going +to explain such new features here, we should just like to point out that the syntax +given as rail road diagrams is complete. If you want to (cid:2)nd out more bout the +keyword volatile you should consult the C reference manual [7]. + +Types are constructed using structures, unions and enumerations, as discussed + +in Chapter 4. + +??? + +??? + +(cid:1)(cid:3)(cid:2) + +??? + +??? + +Revision: 6.8 + +(cid:0) +(cid:4) +(cid:0) +(cid:1) +(cid:2) +(cid:4) +(cid:0) +(cid:1) +(cid:2) +(cid:4) +(cid:0) +(cid:4) +(cid:0) +(cid:1) +(cid:2) +(cid:4) +(cid:0) +(cid:1) +(cid:2) +(cid:4) +(cid:0) +(cid:1) +(cid:2) +(cid:4) +(cid:0) +(cid:4) +(cid:0) +(cid:1) +(cid:2) +(cid:4) + The following syntax is used to declare arguments of functions as well as local +and global variables. This syntax includes the de(cid:2)nitions of function types (to be +passed to higher order functions), array types, and pointer types. + +413 + +(cid:1)(cid:3)(cid:2) + +??? + +??? + +(cid:1)(cid:3)(cid:2) + +??? + +??? + +(cid:1)(cid:3)(cid:2) + +??? + +??? + +(cid:1)(cid:3)(cid:2) + +??? + +??? + +(cid:1)(cid:3)(cid:2) + +??? + +??? + +??? + +The priorities of operators are expressed by a series of railroad diagrams that show +increasing priority. Note that the priorities can pose a few surprises, such as that +the bitwise operators &, | and ˆ have a lower priority than the relational opera- +tors: x&1 == 0 does not test whether the last bit of x is 0, but instead calculates +x&(1==0) which happens to be 0 for all x. + +??? + +??? + +(cid:1)(cid:3)(cid:2) + +??? + +??? + +Revision: 6.8 + +(cid:0) +(cid:4) +(cid:0) +(cid:1) +(cid:2) +(cid:4) +(cid:0) +(cid:4) +(cid:0) +(cid:1) +(cid:2) +(cid:4) +(cid:0) +(cid:4) +(cid:0) +(cid:1) +(cid:2) +(cid:4) +(cid:0) +(cid:4) +(cid:0) +(cid:1) +(cid:2) +(cid:4) +(cid:0) +(cid:4) +(cid:0) +(cid:1) +(cid:2) +(cid:4) +(cid:0) +(cid:1) +(cid:2) +(cid:4) +(cid:0) +(cid:1) +(cid:2) +(cid:4) +(cid:0) +(cid:1) +(cid:2) +(cid:4) +(cid:0) +(cid:4) +(cid:0) +(cid:1) +(cid:2) +(cid:4) + 414 + +AppendixD. ISO-Csyntaxdiagrams + +??? + +??? + +(cid:1)(cid:3)(cid:2) + +??? + +(cid:1)(cid:3)(cid:2) + +??? + +??? + +??? + +??? + +(cid:1)(cid:3)(cid:2) + +??? + +(cid:1)(cid:3)(cid:2) + +??? + +??? + +??? + +(cid:1)(cid:3)(cid:2) + +??? + +(cid:1)(cid:3)(cid:2) + +??? + +??? + +There are no diagrams for the symbols that represent identi(cid:2)ers, constants and +strings, they would not give much useful information. Instead we give an infor- +mal de(cid:2)nition of each of these terms: + +identi(cid:2)er A sequence composed of characters, underscores, and digits that does + +not start with a digit. + +integer(cid:1)constant A decimal number, or a hexadecimal number pre(cid:2)xed with 0x, + +or an octal number pre(cid:2)xed with a 0. + +character(cid:1)constant A single character enclosed in (cid:146) +cape (a full list is given in Section 2.3.3). + +characters, or a backslash es- + +Revision: 6.8 + +(cid:0) +(cid:1) +(cid:2) +(cid:4) +(cid:0) +(cid:1) +(cid:2) +(cid:4) +(cid:0) +(cid:4) +(cid:0) +(cid:4) +(cid:0) +(cid:1) +(cid:2) +(cid:4) +(cid:0) +(cid:1) +(cid:2) +(cid:4) +(cid:0) +(cid:1) +(cid:2) +(cid:4) +(cid:0) +(cid:4) +(cid:0) +(cid:4) +(cid:0) +(cid:1) +(cid:2) +(cid:4) +(cid:0) +(cid:1) +(cid:2) +(cid:4) +(cid:0) +(cid:4) +(cid:0) +(cid:4) +(cid:0) +(cid:1) +(cid:2) +(cid:4) + 415 + +(cid:3)oating(cid:1)constant A number consisting of a integral part, a fractional part, and an +exponent. The exponent must be pre(cid:2)xed with the letter e (or E), the frac- +tional part must be pre(cid:2)xed with a decimal point. One of the fractional and +exponential part is optional. + +enumeration(cid:1)constant An identi(cid:2)er that has appeared in an enum declaration. + +string A sequence of characters enclosed between double quotes, ". + +Revision: 6.8 + + 416 + +AppendixD. ISO-Csyntaxdiagrams + +Revision: 6.8 + + \ No newline at end of file