sedgewick - programming in java

An Interdisciplinary Approach

Robert Sedgewick Kevin Wayne

Introduction

to

Programming in Java

Introduction

to

Programming in Java

An Interdisciplinary Approach

Robert Sedgewickand

KevinWayne

Princeton University

Boston San Francisco NewYork

London Toronto Sydney Tokyo Singapore Madrid

Mexico City Munich Paris Cape Town Hong Kong Montreal

Publisher GregTobinExecutive Editor Michael Hirsch

Associate Editor LindseyTriebelAssociate ManagingEditor Jeffrey HolcombSeniorDesigner Joyce Cosentino WellsDigital Assets Manager Marianne GrothSenior MediaProducer BethanyTiddSeniorMarketingManager Michelle BrownMarketingAssistant SarahMilmoreSenior Author Support/

Technology Specialist JoeVetereSeniorManufacturingBuyer CarolMelvilleCopyeditor Genevieve d'EntremontComposition andIllustrations Robert Sedgewick andKevin Wayne

Cover Image: ©RobertSedgewick and Kevin Wayne

Page 353 ©2006 C.Herscovici, Brussels / Artists Rights Society (ARS), New York Banque d' Images, ADAGP / ArtResource, NY

Many ofthe designations used by manufacturers and sellers todistinguish their products are claimed as trademarks. Where those designations appear in this book, and Addison-Wesley was aware ofa trademark claim, thedesignations have beenprinted in initial caps orallcaps.

The interior of this book was composedin AdobeInDesign.

LibraryofCongressCataloging-in-Publication Data

Sedgewick, Robert, 1946-Introduction toprogramming inJava: aninterdisciplinary approach / byRobert Sedgewick andKevin Wayne.

p. cm.

Includes index.

ISBN978-0-321-49805-2 (alk. paper)1. Java (Computer program language) 2. Computer programming. I.Wayne, Kevin Daniel, 1971- II.Title.QA76.73.J38S413 2007005.13'3-dc22

2007020235

Copyright ©2008 Pearson Education, Inc. All rights reserved. No partof this publication may be reproduced,stored in a retrieval system, or transmitted, in anyform or byanymeans, electronic, mechanical, photocopying,recording, or otherwise, without theprior written permission of thepublisher. Printed in theUnited States ofAmerica. Forinformationon obtainingpermissionfor useof materialin thiswork,pleasesubmit a written requestto PearsonEducation, Inc., Rightsand Contracts Department, 501 BoylstonStreet,Suite900,Boston,MA02116,fax (617) 671-3447, or online at http: //www.pearsoned. com/1egal /permi ssi ons. htm.

ISBN-13:978-0-321-49805-2

ISBN-10:0-321-49805-4

123456789 10—CRW—11 10 09 08 07

The basis for education in the lastmillenniumwas "reading, writing,and arithmetic;" now it is reading, writing, and computing. Learning to program is an

essential part of the education of every student in the sciences and engineering.Beyond direct applications, it is the first step in understanding the natureof computer science's undeniable impact on the modern world. This book aims to teachprogramming to those who need or want to learn it, in a scientific context.

Our primary goal is to empower students by supplying the experience andbasic tools necessary to use computation effectively. Our approach is to teach students that writing a program is a natural, satisfying, and creative experience (notan onerous task reserved for experts). We progressively introduce essential concepts, embrace classic applications from applied mathematics and the sciences toillustrate the concepts, andprovide opportunities for students to write programsto solveengagingproblems.

We usethe Java programming language forallof theprograms in thisbook—we refer to Java after programming in the title to emphasize the idea that the bookis aboutfundamental concepts inprogramming, not Java per se. This book teachesbasic skills forcomputational problem-solving thatare applicable inmany moderncomputing environments, and is a self-contained treatment intended for peoplewithno previous experience in programming.

Thisbook is an interdisciplinary approachto the traditional CS1 curriculum,where we highlight the role of computing in otherdisciplines, frommaterials science to genomics to astrophysics to network systems. This approach emphasizesfor students the essential idea that mathematics, science, engineering, and computing are intertwined in the modern world. While it is a CS1 textbook designedfor anyfirst-year college student interested in mathematics, science, or engineering (including computerscience), the book also canbe usedfor self-study or as asupplement in a coursethat integrates programmingwith another field.

VI

Coverage The bookisorganized around fourstages oflearning to program: basic elements, functions, object-oriented programming, and algorithms (with datastructures). We provide thebasic information readers need to buildconfidence inwriting programs at each level before moving to thenext level. An essential featureof our approach is to use example programs that solve intriguing problems, supported with exercises ranging from self-study drills to challenging problems thatcall for creative solutions.

Basic elements include variables, assignment statements, built-in types ofdata,flow of control (conditionals and loops), arrays, and input/output, includinggraphics and sound.

Functions and modules are the student's first exposure to modular programming. We build upon familiarity with mathematical functions to introduce Javastatic methods, and then consider the implications of programming with functions, including libraries of functions and recursion. We stress the fundamentalidea ofdividing a program into components thatcan beindependently debugged,maintained, and reused.

Object-orientedprogramming isourintroduction to data abstraction. We emphasize the concepts ofadata type (aset ofvalues and aset ofoperations onthem)and an object (an entity that holds a data-type value) and their implementationusing Java's class mechanism. We teach students how to use, create, anddesign datatypes. Modularity, encapsulation, and other modern programming paradigms arethe central concepts of this stage.

Algorithms and data structures combine these modern programming paradigms with classic methods of organizing and processing data that remain effective for modern applications. We provide an introduction to classical algorithmsfor sorting and searching as well as fundamental data structures (including stacks,queues, and symbol tables) and their application, emphasizing theuse ofthescientificmethod to understand performance characteristics of implementations.

Applications in science and engineering are a key feature of the text. We motivate each programmingconceptthat we address by examiningits impact on specific applications. We draw examples from applied mathematics, the physical andbiological sciences, andcomputer science itself, andinclude simulation ofphysicalsystems, numerical methods, data visualization, sound synthesis, image processing, financial simulation, and information technology. Specific examples include atreatment in the first chapterof Markov chains for web pageranks and case studies that address the percolation problem, N-body simulation, and the small-world

phenomenon. These applications are an integral partof thetext. They engage students in the material, illustrate theimportance of theprogramming concepts, andprovide persuasive evidence of the critical role played by computation in modernscience and engineering.

Our primary goal is to teach the specific mechanismsand skills that are neededto develop effective solutions to anyprogramming problem. We workwithcomplete Java programs andencourage readers to use them. We focus on programmingby individuals, not library programming or programming in the large (which wetreat briefly in an appendix).

Use in the Curriculum This book is intended for a first-year college courseaimed at teaching novices to program in the context of scientific applications.Taught from thisbook, prospective majors in any area of science and engineeringwill learn to programin a familiar context. Students completing a course basedonthis book willbe well-prepared to apply their skills in later courses in science andengineering and to recognize when further education in computer science mightbe beneficial.

Prospective computer science majors, in particular, canbenefit fromlearningto program in the contextof scientific applications. Acomputer scientist needsthesame basic background in the scientific method and the same exposure to the roleofcomputation in science as does a biologist, an engineer, or a physicist.

Indeed, our interdisciplinary approach enables colleges and universities toteach prospective computer science majors and prospective majors in other fieldsofscience andengineering in thesame course. We cover thematerial prescribed byCS1, but our focus on applications brings life to the concepts and motivates students to learn them. Our interdisciplinary approach exposes students to problemsin manydifferent disciplines, helping themto morewisely choose a major.

Whatever thespecific mechanism, theuse of this bookisbestpositioned earlyin the curriculum. First, this positioning allows us to leverage familiar materialin high school mathematics and science. Second, students who learn to programearly in theircollege curriculum will thenbeable to use computers moreeffectivelywhenmoving on to courses in their specialty. Like reading and writing, programming is certain to be an essential skill for any scientist or engineer. Students whohave grasped the concepts in thisbookwill continually develop that skill through alifetime,reaping the benefits of exploitingcomputation to solve or to better understand the problems and projects that arise in their chosen field.

VII

VIII

Prerequisites This book is meant to be suitable for typical science and engineering students in theirfirst year ofcollege. Thatis, we do not expect preparationbeyond what is typically required for other entry-level science and mathematicscourses.

Mathematical maturity is important. While we do not dwell on mathematical material, we do refer to the mathematics curriculum that students have taken in highschool, including algebra, geometry, and trigonometry. Moststudents in our targetaudience (those intending to major in the sciences and engineering) automaticallymeet these requirements. Indeed, we take advantage of their familiarity with thebasic curriculum to introduce basic programming concepts.

Scientific curiosity is also an essential ingredient. Science and engineering studentsbring with them a sense offascination intheability ofscientific inquiry tohelp explain what goes on innature. We leverage this predilection with examples ofsimpleprograms that speak volumes aboutthe naturalworld. We do not assume anyspecific knowledge beyond that provided bytypical highschool courses in mathematics,physics, biology, or chemistry.

Programming experience is not necessary, but also is not harmful. Teaching programming is our primary goal, sowe assume no prior programming experience.But writing a program to solve a new problem isa challenging intellectual task, sostudents who have written numerous programs in high school can benefit fromtaking an introductory programming course based on this book (just as studentswhohave writtennumerous essays in highschool canbenefit froman introductorywriting course in college). The book can support teaching students with varyingbackgrounds because theapplications appeal to bothnovices andexperts alike.

Experience using a computer is also not necessary, but also is not at all a problem.College students use computers regularly, to communicate with friends and relatives, listento music, process photos,and manyother activities. The realization thatthey can harness the power of their own computer in interesting and importantways is an excitingand lasting lesson.

In summary,virtuallyallstudents in science and engineeringare prepared to take acourse based on this book as a part of their first-semester curriculum.

Goals What can instructors of upper-level courses in science and engineeringexpect of students who have completed a coursebased on this book?

We cover the CS1 curriculum, but anyone who has taught an introductoryprogramming course knows that expectations of instructors in later courses aretypically high: eachinstructorexpects allstudentstobefamiliar withthe computingenvironment and approach that he or she wants to use.A physics professor mightexpect some students to design a program over the weekend to run a simulation; anengineeringprofessor might expectother students to be using a particular packageto numerically solvedifferential equations; or a computer scienceprofessor mightexpect knowledge of the details of a particular programming environment. Is itrealistic to meetsuchdiverse expectations? Should therebe a different introductorycoursefor eachset of students? Colleges and universities have been wrestling withsuch questions since computers came into widespread use in the latter part of the20thcentury. Our answer to them isfound in this commonintroductory treatmentof programming, which is analogous to commonly accepted introductorycoursesin mathematics, physics, biology, and chemistry. An Introduction to Programmingstrives to provide the basic preparation needed by all students in science and engineering, while sending the clear message that there is much more to understandabout computer science than programming. Instructors teaching students whohave studied from this book can expect that theyhave the knowledge and experience necessaryto enable them to adapt to newcomputational environments and toeffectively exploit computers in diverse applications.

What can students who have completed a course based on this book expect to accomplish in later courses?

Our message is that programming is not difficult to learn and that harnessing the power of the computer is rewarding. Students who master the material inthis book are prepared to address computational challenges wherever they mightappear later in their careers. They learn that modern programming environments,such as the one provided by Java, help open the door to any computational problem they might encounter later, and they gain the confidence to learn, evaluate,and use other computational tools. Students interested in computer science will bewell-prepared to pursue that interest; students in science and engineering will beready to integrate computation into their studies.

IX

Booksite An extensive amount of information that supplements this text maybe found on the web at

http://www.cs.pri nceton.edu/IntroProgramming

For economy, we refer to this siteas the booksite throughout. It contains materialfor instructors, students, and casual readers of the book. We briefly describe thismaterialhere,though,asallwebusers know, it isbest surveyed bybrowsing. With afewexceptions to support testing,the material is all publiclyavailable.

One of the most important implications of the booksite is that it empowers instructors and students to use their own computers to teach and learn thematerial. Anyone with a computer and a browser can begin learning to programby following a few instructions on the booksite. The process is no more difficultthan downloading a media player or a song. As with any website, our booksite iscontinually evolving. It isan essential resource foreveryone whoowns thisbook.Inparticular, the supplemental materials arecritical to our goal of making computerscience an integralcomponentof the education of allscientists and engineers.

For instructors, the booksite contains information about teaching. This information is primarilyorganized around a teaching style that we have developedover the past decade, where we offer two lectures per week to a large audience,supplemented by twoclass sessions perweek where studentsmeetin small groupswith instructorsor teaching assistants. Thebooksite has presentationslides for thelectures, which set the tone.

For teaching assistants, the booksite contains detailed problem sets and programming projects, which arebased on exercises from the book but containmuchmore detail.Eachprogramming assignmentis intended to teach a relevantconceptin the contextof an interestingapplicationwhilepresenting an inviting and engaging challenge to each student. The progression of assignments embodies our approach to teachingprogramming. The booksite fullyspecifies all the assignmentsand provides detailed, structured information to help students complete them inthe allotted time, including descriptions of suggested approaches and outlines forwhat should be taught in class sessions.

For students, the booksite contains quick accessto much of the material in thebook, including source code, plus extra material to encourage self-learning. Solutions are provided for many of the book's exercises, including complete programcode and test data. There is a wealth of information associated with programmingassignments, including suggested approaches, checklists, FAQs, and test data.

For casual readers (including instructors, teaching assistants, and students!),the booksite is a resource for accessing all manner of extra information associatedwith the book's content. Allof the booksite content providesweb links and otherroutes to pursue more information about the topic under consideration. There isfar more information accessible than anyindividualcould fullydigest,but our goalis to provide enough to whet any reader's appetite for more information about thebook's content.

Acknowledgements Thisproject has been under development since 1992, sofar too many people have contributed to its success for us to acknowledge themall here. Special thanks are due to Anne Rogers for helping to start the ball rolling;to Dave Hanson, Andrew Appel, and Chris van Wyk, for their patience in explaining data abstraction; and to Lisa Worthington, for being the first to truly relishthe challengeof teaching this material to first-year students. Wealso gratefullyacknowledge the efforts of /dev/126 (the summer students who have contributedso much of the content); the faculty, graduate students, and teaching staff whohave dedicated themselves to teaching this material over the past 15 years here atPrinceton; and the thousands of undergraduates who havededicated themselves tolearning it.

Robert SedgewickMadeira, Portugal

Kevin WayneSanFrancisco, California

July, 2007

XI

Preface v

Elements of Programming 31.1 Your First Program 41.2 Built-in Typesof Data 141.3 Conditionals and Loops 461.4 Arrays 861.5 Input and Output 1201.6 Case Study: Random Web Surfer 162

Functions and Modules 183

2.1 Static Methods 184

2.2 Libraries and Clients 218

2.3 Recursion 254

2.4 Case Study: Percolation 286

Object-Oriented Programming 3153.1 Data Types 3163.2 Creating Data Types 3703.3 Designing Data Types 4163.4 Case Study: N-body Simulation 456

Algorithms and Data Structures 4714.1 Performance 472

4.2 Sorting and Searching 5104.3 Stacks and Queues 550

4.4 Symbol Tables 6084.5 Case Study: Small World 650

Context 695

Index 699

XIII

1.1 Your First Program 4

1.2 Built-in Types of Data 14

1.3 Conditionals and Loops 46

1.4 Arrays 86

1.5 Input and Output 120

1.6 Case Study: Random Web Surfer. . . 162

Our goal in this chapter is to convince you that writing a program is easier thanwriting a piece of text, such as a paragraph or essay. Writing prose is difficult:

we spend many years in school to learn how to do it. Bycontrast, just a fewbuildingblockssufficeto enable us to write programs that can help solveall sorts offascinating, but otherwise unapproachable, problems. In this chapter, we take you throughthese building blocks, get you started on programming in Java,and study a varietyof interesting programs. You will be able to expressyourself (by writing programs)within just a few weeks. Like the ability to write prose, the ability to program is alifetime skill that you can continually refine well into the future.

In this book, you will learn the Javaprogramming language.This task will bemuch easier for you than, for example, learning a foreign language. Indeed, programming languages are characterized by no more than a few dozen vocabularywords and rules of grammar. Much of the material that we cover in this book couldbe expressed in the C or C++ languages, or any of severalother modern programming languages.But we describe everything specifically in Javaso that you can getstarted creating and running programs right away. On the one hand, we will focuson learning to program, as opposed to learning details about Java. On the otherhand, part of the challenge of programming is knowing which details are relevantin a givensituation. Java iswidelyused,so learningto program in this languagewillenable you to write programs on many computers (your own, for example).Also,learning to program in Java willmakeit easyfor you learn other languages, including lower-level languages such as C and specialized languagessuch as Matlab.

Elements of Programming

1.1 Your First Program

In this section, our plan is to lead you into the world of Javaprogramming by taking you through the basicstepsrequired to get a simple program running. The Javasystem is a collection of applications, not unlike many of the other applicationsthat you are accustomed to using (suchas your word processor, email program, LU Heu0, World 6and internet browser). As with any ap- 1.1.2 Using acommand-line argument . . 8plication, you need to be sure that Java Pwpam in this sectionis properly installed on your computer. Itcomes preloaded on many computers, oryou can download it easily. Youalso need a text editor and a terminal application.Your first task is to find the instructions for installing such a Java programmingenvironment on yourcomputer by visiting

http://www.cs.pri nceton.edu/IntroProgrammi ng

We refer to this site as the booksite. It contains an extensive amount of supplementary information about the material in this book for your reference and use. Youwill find it useful to have your browser open to this site while programming.

Programming in Java To introduce you to developing Java programs, webreak the process down into three steps. To program in Java,you need to:

• Create a program by typing it into a file named, say, MyCode. j ava.• Compile it by typing j avac MyCode. j ava in a terminal window.• Run (or execute) it by typing Java MyCode in the terminal window.

In the first step, you start with a blank screen and end with a sequence of typedcharacters on the screen, just as when you write an email message or a paper. Programmers use the term code to refer to program text and the term coding to referto the act of creating and editing the code. In the second step, you use a system application that compiles your program (translates it into a form more suitable for thecomputer) and puts the result in a file named MyCode. cl ass. In the third step,youtransfer control of the computer from the systemto your program (which returnscontrol back to the system when finished). Many systems have several differentways to create, compile, and execute programs. We choose the sequence describedhere because it is the simplestto describe and use for simple programs.

/. / Your First Program

Creating a program. A Java programis nothingmore than a sequence of characters, like a paragraph or a poem, stored in a file with a . Java extension. To createone, therefore, you need only define that sequenceof characters, in the same wayas you do for email or any other computer application.You can use any texteditorfor this task, or you can use one of the more sophisticated program developmentenvironments described on the booksite. Such environments are overkill for the

sorts of programs we consider in this book, but they are not difficult to use, havemany useful features, and are widelyused by professionals.

Compiling a program. Atfirst, it might seem that Java is designed to be best understoodby the computer. To the contrary, the language is designed to be best understood by the programmer (that's you). The computer's language is far moreprimitive than Java. A compiler is an applicationthat translatesa program from theJava languageto a languagemore suitablefor executing on the computer. The compiler takes a file with a . Java extension as input (your program) and produces afile with the same name but with a . cl ass extension (the computer-languageversion). To use your Javacompiler, type in a terminal window the javac commandfollowedby the file name of the program you want to compile.

Executing a program. Onceyou compile the program,you can run it. This is theexcitingpart, where your program takescontrol of your computer (within the constraints of what the Java systemallows). It is perhaps more accurate to saythat yourcomputer follows your instructions. It is even more accurate to say that a part ofthe Javasystem known as the Java Virtual Machine (the /VM, for short) directs yourcomputer to follow your instructions. To use the JVM to execute your program,type the Java command followed by the program name in a terminal window.

use any texteditorto type javac HelloWorid. Java type Java Hell 0W0 ridcreate yourprogram tocompile yourprogram toexecute yourprogram

i i i^HelloWorld. class —editor -^HelloWorid. Java—*- compiler JVM — "Hello, World"

i ' ' I '—' jyour program computer-language mtput

(a textfile) version ofyour program

Developinga Java program


^iMSMte^

m

Program 1.1.1 Hello, World

public class HelloWorld{

public static void main(String[] args){

System.out.print("Hello, World");System.out.p rintln();

}}

This code isaJava program that accomplishes a simple task. It is traditionally a beginner'sfirstprogram. The box below shows what happens when you compile andexecute the program. Theterminal application gives a command prompt (% in this book) and executes the commandsthat you type (javac and then Java in the example below). The result in this case is that theprogram prints a message in the terminal window {the third line).

% javac HelloWorld.java% java HelloWorldHello, World

Program 1.1.1 is an example of a complete Java program. Its name is Hel1oWorld,which means that its code resides in a filenamed Hel1oWo r1d. j ava (by conventionin Java). The program's soleaction is to print a message back to the terminal window. For continuity, we will use some standardJava terms to describethe program,but we will not define them until laterin the book: Program 1.1.1 consists ofa singleclass named Hel 1oWorl d that hasasinglemethodnamed mai n(). This method usestwo other methods named System. out. pri nt () and System. out. pri ntl n() todo the job. (When referring to a method in the text, we use () after the name todistinguish it from other kinds of names.) Until Section 2.1,where we learn aboutclasses that define multiple methods, allofour classes will have this same structure.Forthe time being, you can think of"class" as meaning "program."

The first line of a method specifiesits name and other information; the rest isa sequence of statementsenclosed in braces and each followed by a semicolon. Forthe time being, you can think of "programming" as meaning "specifying a class

7./ Your First Program

name and a sequence of statements for its main() method." In the next two sections, you will learn many differentkinds of statements that you can use to makeprograms. For the moment, we will just use statements for printing to the terminallike the ones in Hel 1 oWorl d.

When you type java followed by aclass name in your terminal application, thesystem calls the main() method that youdefined in that class, and executes its state

ments in order, one by one. Thus, typingjava Hel1oWorld causes the system to callon the mai n () method in Program 1.1.1 and

execute its two statements. The first state

ment callson System. out. pri nt () to printin the terminal window the message between the quotation marks, and the secondstatement calls on System, out. pri ntl n()to terminate the line.

Since the 1970s, it has been a tradition that a beginning programmer's firstprogram should print "Hel 1o, Worl d". So,you should type the code in Program1.1.1 into a file, compile it, and executeit. Bydoing so,you will be following in thefootsteps of countless others who have learned how to program. Also, you will bechecking that you have a usable editor and terminal application. At first, accomplishing the task of printing something out in a terminal window might not seemvery interesting; upon reflection, however, you will see that one of the most basicfunctions that we need from a program is its ability to tell us what it is doing.

For the time being, all our program code will be just like Program 1.1.1, except with a different sequence of statements in mai n(). Thus, you do not need tostart with a blank page to write a program. Instead,you can

• Copy Hel1oWorl d. j ava into a new file having a new program name ofyour choice, followed by . j ava.

• Replace Hel1oWorl d on the first line with the new program name.• Replace the System. out. pri nt () and System. out. pri ntl n() statements

with a different sequence of statements (each ending with a semicolon).Your program is characterized by its sequence of statements and its name. EachJava program must reside in a file whose name matches the one after the wordcl ass on the first line, and it also must have a . java extension.

textfile named HelloWorld. java

name

Ipublic class HelloWorld{

mainQ method

publi c{

static void main(String[] args)

}}

System.out.print("Hello, World");System.out.pri ntln();

statements

Anatomy of a programbody

8

Program 1.1.2 Usinga command-line argument

public class UseArgument{


System.out.print("Hi, ");System.out.pri nt(args[0]);System.out.println(". How are you?");

}}


This program shows thewayin which wecan control the actions ofourprograms: byprovidingan argument on thecommand line. Doingso allows us to tailor thebehavior of ourprograms.

% javac UseArgument.java% java UseArgument AliceHi, Alice. How are you?% java UseArgument BobHi, Bob. How are you?

mmm ^P»p^ss?fs$^3^;?£;

Wfw&^i^M. :iMMMMiM^M

Errors, It is easy to blur the distinction among editing, compiling, and executingprograms. You should keep them separate in your mind when you are learning toprogram, to better understand the effects of the errors that inevitably arise. Youcan find several examples of errors in the Q&Aat the end of this section. You canfix or avoid most errors by carefully examining the program as you create it, thesame way you fix spelling and grammatical errors when you compose an emailmessage. Some errors, known as compile-time errors, are caught when you compilethe program, because they prevent the compiler from doing the translation. Othererrors, known as run-time errors, do not show up until you execute the program.In general, errors in programs, also commonly known as bugs, are the bane of aprogrammer's existence: the error messages can be confusing or misleading, andthe source of the error can be veryhard to find. One of the first skills that you willlearn is to identifyerrors;you willalsolearn to be sufficiently carefulwhen coding,to avoid making many of them in the first place.


Input asid Output Typically, wewant to provide input to our programs: datathat theycan process to producea result. Thesimplest way to provide input data isillustrated in UseArgument (Program 1.1.2).Whenever UseArgument is executed,it reads the command-line argument that you type after the program name andprints it back out to the terminal as part of the message. The result of executingthis program depends on what we type after the program name. After compilingthe program once, we can run it for different command-line arguments and getdifferent printed results.Wewill discuss in more detail the mechanism that we useto pass arguments to our programs later, in Section 2.1. In the meantime, you canuse args [0] within your program's body to represent the string that you type onthe command line when it is executed,just as in UseArgument. Alice -< input string

Again, accomplishing the task ofgetting a program 1to write back out what we type in to it may not seem in- H^^Hteresting at first, but upon reflection you will realize that ^^^H^ bjack boxanother basic function of a program is its ability to re- ^^J|spond tobasic information from the user tocontrol what I output stringthe program does. The simple model that UseArgument Hi, Alice. How are you?represents will suffice to allow us to consider Java's basicprogramming mechanism and to addressallsorts of inter- Abird's-eye view ofaJava programesting computational problems.

Stepping back, we can see that UseArgument does neither more nor less thanimplementa function that mapsa stringof characters (the argument) into anotherstring of characters (the message printed back to the terminal).When using it, wemight think of our Java program as a blackbox that converts our input string tosome output string. This model is attractivebecause it is not only simple but alsosufficiently general to allow completion, in principle, of any computational task.For example, the Java compiler itself is nothing more than a program that takesone string of characters as input (a .java file) and produces another string ofcharactersas output (the corresponding .cl ass file). Later, wewillbe able to writeprograms that accomplish a varietyof interesting tasks (though we stop short ofprograms as complicated as a compiler). For the moment, we livewith various limitations on the size and type of the input and output to our programs; in Section1.5,we will see how to incorporate more sophisticated mechanisms for programinput and output. In particular, we can work with arbitrarily long input and outputstrings and other types of data such as sound and pictures.


K$&A

Q. Why Java?

A. The programs that we are writing are very similar to their counterparts in several other languages, so our choiceof languageis not crucial.We use Javabecauseit is widelyavailable, embracesa full set of modern abstractions, and has a varietyof automatic checks for mistakes in programs, so it is suitable for learning to program.Thereis no perfectlanguage, and you certainlywillbe programming in otherlanguages in the future.

Q. Do I reallyhave to type in the programs in the book to try them out? I believethat you ran them and that they produce the indicated output.

A. Everyone should type in and run HelloWorld. Your understanding will begreatly magnified ifyoualsorun UseArgument, try it on variousinputs, and modifyit to test different ideas of your own. To save some typing, you can find all of thecode in this book (and much more) on the booksite. This site also has informationabout installing and running Java on your computer, answers to selected exercises,web links, and other extra information that you may find useful or interesting.

Q. What is the meaning of the words pub!i c, stati c and voi d?

A. These keywords specify certain properties of mai n() that you will learn aboutlater in the book. For the moment, we just include these keywords in the code (because they are required) but do not refer to them in the text.

Q. What is the meaning of the //, /*, and */ character sequences in the code?

A. Theydenote comments, whichare ignoredby the compiler.A comment is eithertext in between /* and */ or at the end of a line after //. As with most online code,the code on the booksite is liberallyannotated with comments that explain what itdoes; we use fewer comments in code in this book because the accompanying textand figures provide the explanation.

Q. What are Java's rules regarding tabs, spaces, and newline characters?

A. Such characters are known as whitespace characters. Java compilers considerall whitespace in program text to be equivalent. For example, we could write Hel-


loWorld as follows:

public class HelloWorld { public static void main ( String []args) { System.out.print("Hello, World") ; System.out.println() ;} }

But we do normally adhere to spacing and indenting conventions when we writeJava programs, just as we always indent paragraphs and lines consistentlywhen wewrite prose or poetry.

Q. What are the rules regardingquotation marks?

A. Material inside quotation marks is an exception to the rule definedin the previous question: things within quotes are taken literallyso that you can preciselyspecify what gets printed. If you put any number of successive spaceswithin thequotes, you get that number of spaces in the output. If you accidentally omit aquotation mark, the compiler may get very confused, because it needs that mark todistinguishbetweencharactersin the string and other parts of the program.

Q. What happenswhenyou omit a braceor misspell one of the words,like pub!i cor stati c or voi d or mai n?

A. It depends upon precisely what you do.Sucherrors are called syntax errors andare usuallycaught by the compiler. For example, if you make a program Bad that isexactly the same as Hel 1oWorl d except that you omit the line containing the firstleft brace (and change the program name from HelloWorld to Bad), you get thefollowing helpful message:

% javac Bad.javaBad.java:2: ,{l expected

public static void main(String[] args)A

1 error

From this message,you might correctly surmise that you need to insert a left brace.But the compiler may not be able to tell you exactlywhat mistake you made, so theerror message maybe hard to understand. For example, if you omit the second leftbrace instead of the first one, you get the following messages:

11


% javac Bad.javaBad.java:4: f;' expected

System.out.print("Hello, World");A

Bad.java:7: 'class1 or 'interface1 expected}A

Bad.java:8: 'class1 or 'interface1 expectedA

3 errors

One wayto get used to such messages is to intentionallyintroduce mistakes into asimple program and then seewhat happens.Whatever the error message says, youshould treat the compiler as a friend, for it is just trying to tell you that somethingis wrong with your program.

Q. Can a program use more than one command-line argument?

A. Yes, you can use many arguments,though we normally use just a few. Note thatthe count starts at 0, so you refer to the first argument as args [0], the second oneas args [1], the third one as args [2], and so forth.

Q. What Java methods are available for me to use?

A. There are literallythousands of them. Weintroduce them to you in a deliberate

fashion (starting in the next section) to avoidoverwhelmingyou with choices.

Q. When I ran UseArgument, I got a strange error message. What's the problem?

A. Most likely, you forgot to include a command-line argument:

% java UseArgumentHi, Exception in thread "main"java.lang.ArraylndexOutOfBoundsException: 0

at UseArgument.mai n(UseArgument.j ava:6)

The JVM is complaining that you ran the program but did not type an argument aspromised. Youwill learn more details about array indices in Section 1.4.Rememberthis error message: you are likely to see it again. Even experienced programmersforget to type arguments on occasion.

/. 7 Your First Program

1.1.1 Write a program that prints the Hello, World message 10 times.

1.1.2 Describewhat happens if you omit the following in Hel 1oWorl d. j ava:a. public

b. static

c. voi d

d. args

1.1.3 Describewhat happens if you misspell (by, say, omitting the second letter)the following in Hel1oWorl d. j ava:

a. public

b. stati c

c. voi d

d. args

1.1.4 Describe what happens if you try to executeUseArgument with each of thefollowing command lines:

a. java UseArgument java

b. java UseArgument @!&a%c. java UseArgument 1234

d. java UseArgument.java Bobe. java UseArgument Alice Bob

1.1.5 Modify UseArgument. java to makea program UseThree. java that takesthree names and prints out a proper sentence with the names in the reverse of theorder given, so that, for example, java UseThree Alice Bob Carol gives HiCarol, Bob, and Alice.

13


le2 Built-in Types of Data

When programming in Java, you must always be aware of the type of data that yourprogram is processing. The programsin Section 1.1 process strings of characters,many of the programs in this section process numbers, and we consider numerous other types later in the book. Understanding the distinctions among them is L2.i String concatenation example ... 20so important that we formally define the 1.2.2 Integer multiplication and division 22idea: a data type isa set ofvalues anda set L2-3 Quadratic formula 24ofoperations defined on those values. You !«" *fp.year / ' \ H

r ... . , . r 1.2.5 Casting to get a random mteger . . 33are familiar with various types of numbers, such as integers and real numbers, Programs in this sectionand with operations defined on them,such as addition and multiplication. In mathematics, we are accustomed to thinking of sets of numbers as being infinite; in computer programs we have to workwith a finite number of possibilities. Each operation that we perform is well-defined onlyfor the finite set of values in an associated data type.

There are eight primitive types of data in Java, mostly for different kinds ofnumbers. Of the eight primitive types,we most often use these: i nt for integers;doubl e for real numbers; and boo! ean for true-false values. There are other typesof data available in Javalibraries: for example,the programs in Section 1.1 use thetype St ri ng for strings of characters. Java treats the Stri ng type differently fromother typesbecause its usage for input and output is essential. Accordingly, it sharessome characteristics of the primitive types: for example, some of its operations arebuilt in to the Java language. For clarity, we refer to primitive types and Stringcollectively as built-in types. For the time being, we concentrate on programs thatare based on computing with built-in types. Later,you will learn about Javalibrarydata types and building your own data types. Indeed, programming in Javais oftencentered on building data types, as you shall see in Chapter 3.

After defining basic terms, we consider several sample programs and codefragments that illustrate the use of different types of data. These code fragmentsdo not do much real computing, but you will soon see similar code in longer programs. Understanding data types (values and operations on them) is an essentialstep in beginning to program. It sets the stage for us to begin working with moreintricate programs in the next section. Every program that you write will use codelike the tiny fragments shown in this section.

1.2 Built-in Types of Data

type set of values common operators sample literalvalues

int integers + - * / % 99 -12 2147483647

double floating-point numbers + - * / 3.14 -2.5 6.022e23

boolean boolean values && || ! true false

char characters,A, ,1. ,%, ,\n,

String sequences of characters + "AB" Hello" "2.5"

Basic built-in data types

Definitions To talk about data types, we need to introduce someterminology.Todo so,westart with the following codefragment:

int a, b, c;a = 1234;b = 99;c = a + b;

The first line is a declaration that declares the names of three variables to be the

identifiers a, b, and c and their type to be i nt. The next three lines are assignmentstatements that change the values of the variables, using the literals 1234 and 99,and the expression a + b, with the end result that c has the value 1333.

Identifiers. We useidentifiers to name variables (and many other things) in Java.An identifieris a sequence of letters, digits, _, and $,the firstof whichis not a digit.The sequencesof characters abc, Ab$, abcl23, and a_b are all legalJavaidentifiers,but Ab*, labc, and a+b are not. Identifiers are case-sensitive, so Ab,ab, and AB are alldifferent names. You cannot use certain reserved words—such as publ i c, stati c,i nt, doubl e, and so forth—to name variables.

Literals. A literal is a source-code representation of a data-type value. We usestrings of digits like 1234 or 99 to define i nt literal values,and add a decimal pointas in 3.14159 or 2.71828 to define doubl e literal values.Tospecifya bool ean value, we use the keywords true or fal se, and to specifya Stri ng,we use a sequenceof characters enclosed in quotes, such as "Hel1o, Worl d". We will consider otherkinds of literals as we consider each data type in more detail.

Variables. A variable is a name that we use to refer to a data-type value. We usevariables to keep track of changing values as a computation unfolds. For example,

15

16 Elements of Programming

we use the variable n in many programsto count things.We createa variable in adeclaration that specifies its type and gives it a name.Wecompute with it by usingthe name in an expression that uses operations defined for its type. Each variablealways stores one of the permissible data-typevalues.

Declaration statements. A declaration statement associates a variable name with

a type at compile time. Java requires us to use declarations to specify the namesand types of variables. Bydoing so, we are being explicitabout any computationthat weare specifying. Java is saidto be a strongly-typed language, because the Javacompiler cancheck forconsistency at compile time (forexample, it doesnot permitus to add a String to a double). This situation is precisely analogous to makingsure that quantities have the proper units in a sci- dedamion smemententific application (for example, it does not makesense to add a quantity measured in inches to an- variable name^other measured in pounds). Declarations can ap- assignmentpear anywherebefore a variable is first used—most statementoften, we put them at the point of first use. *-

combined declaration

Assignment statements. An assignment statement -das^nment statementassociates a data-type value with a variable. When jjsing aprimitive data typewe write c = a + b in Java, we are not expressingmathematical equality, but are instead expressing an action: set the value of thevariable c to be the value of a plus the value of b. It is true that c is mathematicallyequal to a + b immediately after the assignment statement has been executed, butthe point of the statement is to changethe value of c (if necessary). The left-handside of an assignment statement must be a singlevariable; the right-hand side canbe an arbitrary expression that produces valuesof the type. For example,we can saydiscriminant = b*b - 4*a*c in Java, but we cannot say a + b = b + aorl = a.In short, the meaning of= isdecidedly notthe same as in mathematical equations. Forexample, a = b is certainly not the same as b = a, and while the value of c is thevalue of a plus the value of b after c = a + b has been executed, that may cease tobe the case if subsequent statements change the values of any of the variables.

Initialization. In a simple declaration, the initial value of the variable is undefined. For economy,we can combine a declaration with an assignment statement toprovide an initial value for the variable.

1

i

|ints a =

-b =

a, b;|

11234|199;

- literal

|int c = a + b:|


Tracing changes in variable values. As a final check on your understanding ofthe purpose of assignment statements, convince yourself that the following codeexchanges the values of a and b (assume that a and b are i nt variables):

int t = a;a = b;b = t;

To do so,use a time-honored method of examining program behavior: study a table of the variable values aftereach statement (such a table is known as a trace).

Expressions. An expression is a literal, a variable, or asequence of operations on literals and/or variables thatproducesa value. For primitive types, expressions lookjust like mathematical formulas, which are based on familiar symbols or operators that specify data-typeoperations to be performed on one or more operands. Each operand can be anyexpression. Mostof the operatorsthat weuseare binary operators that take exactlytwooperands, suchasx +1 ory / 2.Anexpression that isenclosed in parenthesesis another expression with the samevalue. Forexample, wecanwrite 4 * (x - 3) or

operands 4*x ~12 on the right-hand side of an assignment statement(and expressions) anc[ fa compiler will understandwhatwemean.

0 11 ( x - 3 )] Precedence. Such expressions are shorthand for specifying aI sequence ofcomputations: inwhat ordershould theybeper

formed? Java has natural and well-defined precedence rulesAnatomy ofan expression (see fa booksite) that fully specify this order. For arithmetic

operations, multiplication and division are performed beforeaddition and subtraction, so that a-b*c and a- (b*c) representthe same sequenceof operations. When arithmetic operators have the same precedence, the order isdetermined by left-associativity\ so that a-b-c and (a-b) -c represent the same sequence of operations. You can use parentheses to override the rules, so you shouldnot need to worry about the details of precedence for most of the programs thatyou write. (Some of the programs that you read might depend subtly on precedence rules, but we avoid such programs in this book.)

Converting strings to primitive values for command-line arguments. Javaprovides the library methods that we need to convert the strings that we type as

operator

int a, bJ undefined undefineda = 1234; 1234 undefined

b = 99; 1234 99

int t = a; 1234 99 1234

a = b; 99 99 1234

b = t; 99 1234 1234

Yourfirst trace


command-line arguments into numeric values for primitive types. We use theJava library methods Integer.parselntO and Double.parseDoubleO forthis purpose. For example, typing Integer.parselnt("123") in program textyields theliteral value 123 (typing 123 has thesame effect) andthecode Integer.parselnt (args [0]) produces the same result as the literalvalue typed asa stringon the command line. You will see several examplesof this usage in the programsin this section.

Converting primitive type values to strings for output. As mentioned at thebeginning of this section, the Java built-in Stri ng type obeys special rules. One ofthese special rules isthatyou caneasily convert anytypeofdatato a St ri ng: whenever weusethe + operatorwitha St ri ng asone of itsoperands, Java automaticallyconverts the other to a St ri ng, producingasa result the Stri ng formed from thecharacters of the first operand followed by the characters of the second operand.For example, the resultof thesetwo codefragments

String a = "1234"; String a = "1234";String b = "99"; int b = 99;String c = a + b; String c = a + b;

are both the same: they assign to c the value "123499". We use this automaticconversion liberally to form Stri ng values for System.out. pri nt () and System.out. pri ntl n() for output. For example, wecan write statements likethis one:

System.out.println(a + " + " + b + " = " + c);

If a, b, and c are int variables with the values 1234,99, and 1333, respectively, thenthis statement prints out the string 1234 + 99 = 1333.

With these mechanisms, our view of each Java program as a black box that takesstring arguments and produces string results is stillvalid,but we can now interpretthose strings as numbers and use them as the basis for meaningful computation.Next, we consider these details for the basic built-in types that you will use mostoften (strings, integers, floating-point numbers, and true-false values), alongwithsample code illustrating their use. To understand how to use a data type, you needto know not just its defined set of values, but also which operations you can perform, the language mechanism for invoking the operations, and the conventionsfor specifying literal values.


Characters and Strings Achar isan alphanumeric character or symbol, likethe ones that you type. There are 216 different possible character values, but weusuallyrestrict attention to the ones that representletters,numbers, symbols, and whitespace characterssuch as taband newline. Literals for char are characters enclosed in

singlequotes; for example, ' a' represents the letter a. Fortab,newline, backslash, single quoteand doublequote,weuse the special escape sequences f\t', f\n!, f\\', ' \f f,and ,\" \ respectively. The characters are encoded as16-bit integers using an encoding schemeknown as Unicode,and there are escape sequences for specifying specialcharactersnot found on your keyboard (see the booksite).We usually do not performanyoperations directly on characters other than assigning values to variables.

A St ri ng is a sequenceof characters. Aliteral St ri ng is a sequence of characterswithin double quotes, suchas "He! 1o, Worl d". The St ri ngdata type is notaprimitivetype,but Java sometimes treatsit like one.Forexample, the concatenationoperator (+) that wejust considered isbuilt in to the language as a binary operatorin the same wayas familiar operations on numbers.

The concatenation operation (along with the abilityto declare Stri ng variables and to use them in expressions and assignment statements) is sufficientlypowerful to allow us to attack some nontrivial computing tasks. As an example,

Ruler (Program 1.2.1) computes a table ofvalues of the ruler function that describesthe relative lengths of the marks on a ruler.One noteworthy feature of this computation is that it illustrates how easyis is to craftshort programs that produce huge amountsof output. If you extend this program in theobvious wayto print five lines, six lines, seven lines, and so forth, you will see that eachtime you add just two statements to this

program, you increase the size of its output by preciselyone more than a factor oftwo. Specifically, if the program prints n lines, the nthline contains 2"— 1 numbers.For example, if you were to add statements in this way so that the program prints30 lines, it would attempt to print more than 1 billion numbers.

19

values

typicalliterals

operation

operator

sequences of characters

'Hello," "1 " " * "

concatenate

expression

"Hi, " + "Bob"

"1" + " 2 " + "1"

'1234" + " + " + "99

"1234" + "99"

value

"Hi, Bob"

"1 2 1"

'1234 + 99"

"123499"

Typical Stri ng expressions

Java's built-in Stri ng data type


fcfefe^^^

fts$3

5S?f#3

Program 1.2.1 Stringconcatenation example

public class Ruler{


String rulerl = "1";String ruler2 = rulerl + " 2String ruler3 = ruler2 + " 3String ruler4 = ruler3 + " 4System.out.pri ntln(rulerl);System.out.pri ntln(ruler2);System.out.pri ntln(ruler3);System.out.pri ntln(ruler4);

}}

+ rulerl;+ ruler2;+ ruler3;

This program prints the relative lengths of the subdivisions on a ruler. The nth line ofoutputis the relative lengths of the marks on a ruler subdivided in intervals of 1/2" ofan inch. Forexample, thefourth line ofoutput gives the relative lengths ofthe marks that indicate intervalsofone-sixteenth ofan inch ona ruler.

% javac Ruler.Java% Java Ruler1

12 1

12 13 12 1

121312141213121

mmm. S5^fi«3>?jK&?^»4)?5C rf&m!$$?w^$&WJ&&%^^^%^

I I I I I I I I I I I

121312141213121

The rulerfunction for n = 4

WUPWiPSi^^W

As just discussed, our most frequent use (by far) of the concatenationoperation isto put together results of computation for output with System. out. pri nt () andSystem. out. pri ntl n(). For example, we could simplify UseArgument (Program1.1.2)by replacing its three statements with this single statement:

System.out.println("Hi, " + args[0] + ". How are you?");

We have considered the String type first precisely because we need it for output(and command-line input) in programs that process other types of data.


Integers An i nt is an integer (natural number) between -2147483648 (-231)and 2147483647 (231-1). These bounds derive from the fact that integers are represented in binary with 32 binary digits: there are 232 possible values. (The termbinary digit isomnipresent in computer science, andwe nearly always use theabbreviation bit: abitiseither 0or 1.) The range ofpossible i nt values isasymmetricbecause zero is includedwith the positive values. See the booksite for more detailsabout number representation, but in the present context it suffices to know thatan i nt is one of the finite set of values in the rangejustgiven. Sequences of thecharacters 0 through 9, expressionpossibly witha plusor minus sign at the beginning(that, when interpreted as decimal numbers, fallwithin the defined range),are integer literalvalues.We use i nts frequently because theynaturally arisewhen implementing programs.

Standard arithmetic operators for addition/subtraction (+ and -), multiplication (*), division(/), and remainder (%) for the int data type arebuilt in to Java. These operators take two i nt operands and produce an i nt result, withone significant exception—division or remainder by zero is (not allowed. These operationsaredefined just as in 3grade school (keeping in mind that all results mustbe integers):giventwo i nt valuesa and b,the valueof a / b is the number of times b goes into a withthe fractional part discarded, andthevalue of a % b is theremainder that you getwhenyou dividea by b.Forexample, the value of 17 / 3is 5,and the valueof 17%3is2. The i nt results thatwe get from arithmetic operations are justwhat we expect,except that if the result is too large to fit into i nt's 32-bit representation, then itwill be truncated in a well-defined manner. This situation isknown asoverflow. In

value comment

21

5

5

5

5

5

1

3 *

3 +

3 -

3 -

- (

/ 0

5 -

/

8

2

15

1

2

13

5

-4

-4

0

no fractional part

remainder

run-time error

* has precedence

/ has precedence

left associative

better style

unambiguous

values

typical literals

operations

operators

add

+

Typical int expressions

integers between -231 and +231 -1

1234 99 -99 0 1000000

subtract multiply divide

/

Java's built-in i nt data type

remainder

22

as


Program 1.2.2 Integer multiplication anddivision

^^$JiiL^&£AJii&&?x&&'±li!£i^v\;Vi

public class IntOps

{public static void main(String[] args){

int a = Integer.parselnt(args[0]);int b = Integer.parselnt(args[1]);int p = a * b;int q = a / b;int r = a % b;System.out.println(a + " * " + b + 'System.out.println(a + " / " + b + 'System.out.println(a + " % " + b + 'System.out.println(a + " = " + q + '

}}

+ P);+ q);+ r);+ b + + r);

Arithmetic for integers is built in to Java. Most ofthis code is devoted to the task ofgetting thevalues inand out; the actual arithmetic isinthe simple statements in the middle ofthe programthatassign values to p, q, and r.

% javac IntOps.Java% Java IntOps 1234 991234 * 99 = 122166

1234 / 99 = 121234 % 99 = 46

1234 = 12 * 99 + 46

*iHiliiliPi WPP^g

general, wehave to take care that such a result isnot misinterpreted by ourcode.For the moment, we willbe computingwith small numbers, so you do not havetoworry about theseboundary conditions.

Program 1.2.2 illustrates basic operations for manipulating integers, suchasthe useof expressions involving arithmetic operators. It also demonstrates the useof Integer.parselnt() to convert String values on the command line to intvalues, as well as the use of automatic type conversion to convert i nt values toStri ng values for output.


Three other built-in types are different representations of integers in Java.The long, short, and byte types are the same as int except that they use 64,16,and 8 bits respectively, so the range of allowed values isaccordingly different. Programmers use long whenworking withhuge integers, and the other types to savespace. You canfind a table with the maximum andminimum values for each typeon the booksite, or youcanfigure themout foryourself from the numbers of bits.

Floating-point numbers The double type is for representing floating-pointnumbers, for use in scientific andcommercial applications. Theinternal representation is like scientific notation, so that we cancompute with numbers in a hugerange. We use floating-point numbers to represent realnumbers,but theyaredecidedly not thesameas realnumbers! Thereare infinitely manyreal numbers, but we can only represent a finitenumber of floating-points in any digital computer representation. Floating-point numbersdo approximate real numbers sufficiently wellthat we can use them in applications, but weoften need to cope with the fact that we cannotalways do exact computations.

We can use a sequence of digits with adecimal point to type floating-point numbers.For example, 3.14159 represents a six-digit approximation to it. Alternatively, we can use a notation like scientificnotation: theliteral 6.022e23 represents the number6.022 X 1023. As withintegers, youcan usethese conventions to write floating-point literals in your programs or to providefloating-point numbers as string parameters on the command line.

The arithmetic operators +, -, *, and / are defined for double. Beyond thebuilt-in operators, the Java Math library defines the square root, trigonometric

expression value

23

3.141 + .03

3.141 - .03

6.02e23 / 2.0

5.0 / 3.0

10.0 % 3.141

1.0 / 0.0

Math.sqrt(2.0)

Math.sqrt(-l.O)

3.171

3.111

3.01e23

1.6666666666666667

0.577

Infinity

1.4142135623730951

NaN

values

typical literals

operations

operators

Typical doubl e expressions

real numbers (specified by IEEE 754 standard)

3.14159 6.022e23 -3.0 2.0 1.4142135623730951

add subtract multiply divide

+ /

Java's built-in doubl e data type


[ftffla*^^^^

ft

*•«#:"£'$

Program 1.2.3 Quadratic formula

public class Quadratic{


double b = Double.parseDouble(args[0]);double c = Double.parseDouble(args[l]);double discriminant = b*b - 4.0*c;double d = Math.sqrt(discriminant);System.out.println((-b + d) / 2.0);System.out.println((-b - d) / 2.0);

}

This program prints out the roots ofthe polynomial x2 + bx + c, using the quadraticformula.For example, the roots ofx2 - 3x+ 2 are 1 and 2 since we can factor the equation as (x - 1)(x- 2); the roots ofx2 -x-1 are$ and 1 - 4>, where (|> isthe golden ratio, and the roots ofx2 +x + 1 are not real numbers.

% javac Quadratic.Java% Java Quadratic -3.0 2.02.0

1.0

^^sss wmmmmMsmmZ&SPW^F-i

% Java Quadratic -1.0 -1.01.618033988749895

-0.6180339887498949

% Java Quadratic 1.0 1.0NaN

NaN

^^S^S^S^R^^^^i^SSI^P^^pi^^^^^^S^^^

SiW

Nf.

W

ift

Wi

m

functions, logarithm/exponential functions, and other common functions forfloating-point numbers. To use oneof these values in an expression, wewrite thename of the function followed by its argument in parentheses. For example, youcanuse the code Math. sqrt (2.0) when you want to use the square root of 2 in anexpression. We discuss in moredetail the mechanism behind this arrangement inSection 2.1 and more detailsabout the Math library at the end of this section.

When working with floating point numbers, one of the first things thatyou will encounter is the issue of precision: 5.0/2.0 is 2.5 but 5.0/3.0 is1.6666666666666667.In Section 1.5, you will learn Java's mechanism for control-


lingthe numberofsignificant digits thatyousee in output.Until then,we will workwith the Java defaultoutput format.

The result of a calculation can be one of the special values Infi ni ty (if thenumber is too large to be represented) or NaN (if the result of the calculation isundefined). Though there are myriad details to considerwhen calculationsinvolvethese values, youcanuse doubl e in a natural way andbegin to write Java programsinstead of using a calculator for all kinds of calculations. For example, Program1.2.3 shows the use of doubl e values in computing the roots of a quadratic equation using the quadratic formula. Several of the exercises at the end of this sectionfurther illustrate this point.

As with long, short, and byte for integers, there is another representationfor real numbers called f1oat. Programmers sometimes use f1oat to save spacewhen precision is a secondary consideration. The double type is useful for about15 significant digits; the f1oat type is good for onlyabout 7 digits. We do not usef 1oat in this book.

25

values

literals

operations

operators

true or false

true false

and

&& II

not

Booleans The boolean type has just two values: trueand f al se. These are the two possible boolean literals. Every boolean variable has one of thesetwovalues, and everybool ean operation has operands and a result that takes onjust one of these two values. This simplicity is deceiving—bool ean valueslie at the foundation of computer science.

The most important operations defined for booleans are and (&&), or (| |),and not (!), which have familiar definitions:

• a && b is true if both operands are true, and fal se if either is fal se.• a || b is f al se if both operands are fal se, and true if either is true.• !a is true if a is fal se, and fal se if a is true.

Despite the intuitive nature of these definitions, it is worthwhile to fully specifyeach possibility for each operation in tablesknown as truth tables. The notfunction

Java s built-in bool ean data type

!a a && b

true false false false false false

false true false true false true

true false false true

true true true true

Truth-table definitions of bool ean operations


a && b !a !a | | !b !(!a !b)

false false false true true true false

false true false true false true false

true false false false true true false

true true true false false false true

Truth--table proofthata && b and !(!a || •b) are identical

has only oneoperand: itsvalue for each ofthetwo possible values oftheoperand isspecified in thesecond column. The and andor functions each have two operands:therearefour different possibilities foroperandinput values, and the values of thefunctions for eachpossibility are specified in the right two columns.

We can use these operators with parentheses to develop arbitrarily complexexpressions, each of which specifies a well-defined boolean function. Often thesame function appears in different guises. For example, the expressions (a && b)and ! (! a 11 !b) are equivalent.

Thestudy ofmanipulating expressions of thiskindisknown asBoolean logic.This field of mathematics is fundamental to computing: it plays an essential rolein the design and operation of computer hardware itself, and it is also a startingpoint for the theoretical foundations ofcomputation. In the presentcontext, weareinterested in boolean expressions because we use them to control the behaviorofour programs. Typically, a particular condition of interest is specified asa booleanexpression and a piece of program code iswritten to execute one setof statementsif the expression is true and a different setof statements if the expression is fal se.The mechanics of doing so are the topic of Section 1.3.

Comparisons Some mixed-type operators take operands of one type and produce a result of another type. The most important operators of this kind are thecomparison operators ==, !=, <, <=, >, and >=, which allaredefined for each primitivenumeric type and producea boolean result. Since operationsare defined only

non-negative discriminant? (b*b - 4.0*a*c) >= 0.0

beginning ofa century? (year % 100) == 0

legal month? (month >= 1) && (month <= 12)

Typical comparison expressions


w^ii^^sail

IfW£

Program 1.2.4 Leap year

public class LeapYear{


int year = Integer.parselnt(args[0]);boolean isLeapYear;isLeapYear = (year % 4 == 0);isLeapYear = isLeapYear && (year % 100 != 0);isLeapYear = isLeapYear || (year % 400 == 0);System.out.pri ntln(i sLeapYear);

}}

This program tests whether an integer corresponds to a leap year in the Gregorian calendar. Ayear isa leap year if it isdivisible by 4 (2004), unless it isdivisible by 100 inwhich case it isnot(1900), unless it is divisible by400 in which case it is (2000).

% javac LeapYear.java% java LeapYear 2004true

% java LeapYear 1900false

% java LeapYear 2000true

^w^^Sf|?$£*^^"!•s^^ra^i^^sqs^Kipqs^jj^^^^^^gp^Fss?'

with respect to data types, each of thesesymbols stands for many operations, onefor each data type. It is required thatboth operands be of the same type.The resultis always bool ean.

Even without going into the details of number representation, it is clear thatthe operations for the various types are really quite different: forexample, it is onething to compare two i nts to check that (2 <= 2) is true but quite another tocompare two doubl es to check whether (2.0 <= 0.002e3) is true or fal se. Still,these operations arewell-defined and useful to write code that tests for conditionssuchas(b*b - 4.0*a*c) >= 0.0, which is frequently needed, asyou will see.

27


The comparison operations have lower precedence than arithmetic operatorsand higher precedence than boolean operators, soyoudonot need the parenthesesin anexpression like (b*b - 4.0*a*c) >= 0.0, andyoucould write anexpressionlikemonth >= 1 && month <= 12without parentheses to testwhetherthe valueofthe i nt variable month isbetween 1and 12. (It isbetter style to use the parentheses,

however.)Comparison operations, together

with boolean logic,provide the basis fordecision-making in Java programs. Program 1.2.4 is an example of their use,and you can find other examples in theexercises at the end of this section. More

importantly, in Section 1.3 we will seethe role that boolean expressions play inmore sophisticated programs.

true falseop meaning

== equal 2 == 2 2 == 3

!= notequal 3 != 2 2 != 2

< less than 2 < 13 2 < 2

<= less than orequal 2 <= 2 3 <= 2

> greater than 13 > 2 2 > 13

>= greater than orequal 3 >= 2 2 >= 3

Comparisons with i nt operands anda bool ean result

Library methods and APIs As we have seen, many programming tasks involve usingJava library methodsin addition to thebuilt-inoperations on data-typevalues. The number of available library methods is vast.As you learn to program,youwill learn to use more and more library methods, but it isbestatthebeginningto restrict yourattention to a relatively small set of methods. In this chapter, youhave already used some of Java's methods for printing, for converting data fromonetype to another, and for computing mathematical functions (the Java Math library). In later chapters, youwill learn not justhowto useothermethods, but howto createand use your own methods.

For convenience, wewillconsistentlysummarize the librarymethods that youneed to know how to use in tables like this one:

public class System.out

void print (St ring s) prints

voi d pri ntl n(Stri ng s) print s, followed by a newline

voi d pri ntl n() print a newline

Note: Anytype of datacanbeused (and willbeautomatically converted toStri ngj.

Excerpts from Java's libraryfor standard output


Such a table is known as an application programming interface (API). It providesthe informationthat you need to writean application program that uses the methods. Here iS anAPI for the most commonlyusedmethods in Java's Math library:

public class Math

double abs (double a) absolute value ofadouble max (double a, double b) maximum ofa and bdouble mi n(double a, double b) minimum ofaand b

Note 1: abs (), max(), and min() aredefined also for i nt, 1ong, and float.

double sin (double theta) sine functiondouble cos (double theta) cosine functiondouble tan (double theta) tangent function

Note2: Angles are expressed in radians. UsetoDegrees () and toRadi ans () to convert.Note3: Use asi n (), acos (), and atan () for inverse functions.

double exp(double a) exponential(ea)

double log (double a) natural log (loge a, orIn a)double pow(double a, double b) raise a to the bthpower (ab)

long round(double a) round tothe nearest integerdoubl e random() random number in [0,1)

double sqrt (double a) square root ofa

doubl e E value ofe (constant)

doubl e PI value ofit (constant)Seebooksite for other available functions.

ExcerptsfromJava's mathematics library

With the exception of random(), these methods implement mathematical functions—they use their arguments to compute avalueofa specifiedtype. Eachmethod is described by a line in the API that specifies the information you need to knowin order to use the method. The code in the tables is not the code that you type touse the method; it is known as the method's signature. The signature specifies thetype ofthe arguments, the method name, and the type of the value that the methodcomputes (the returnvalue).When your program is executed, we saythat it calls thesystem library code for the method, which returns the value for use in your code.

30

library name

public class Math'

signature

\

method name

-/-double sqrt(double a)

—t 1—return type argument type

Anatomy ofa method signature


Note that random () does not implement a mathematicalfunction because it doesnot take an argument.On the otherhand, System.out.print() and System.out.println()do not implement mathematical functions because they donot return values and therefore do not have a return type.(This condition is specified in the signature by the keywordvoid.)

In your code, you can use a library method by typing its name followed by arguments of the specified type,enclosedin parentheses and separated by commas. You can

use this codein the samewayasyou usevariables and literals in expressions. Whenyou do so, you can expect that method tocompute a value of the appropriate type, asdocumented in the left column of the API.

For example, you can write expressions likeMath.sin(x) * Math.cos(y) and so on.Method arguments may also be expressions,as in Math.sqrt(b*b - 4.0*a*c).

The Math libraryalso defines the precise constantvalues PI (for it) and E(fore), so that you can use those names to referto those constants in your programs.For example, the value of Math. si n(Math.PI/2) is 1.0 and the value of Math.1og(Math. E) is 1.0 (because Math.si n() takes its argument in radiansand Math.1og() implements the naturallogarithm function).

To be complete,we also include here the following API for Java's conversionmethods, which we use for command-line arguments:

int Integer, parselnt (String s) converts to an int value

double Double. parseDouble(String s) converts to a double value

long Long.parseLong(String s) converts to along value

Java library methods for converting strings toprimitive types

library name methodname

\ /double d = Math.sqrt(b*b - 4.0*a*c);

\ /N return type argument

Using a library method

You do not need to use methods like these to convert from i nt, doubl e, and 1ongvalues to String values for output, because Java automatically converts any value used as an argument to System, out. pri nt() or System, out. pri ntl n() toString for output.


expression library type value

Integer.parselnt("123") Integer int 123

Math.sqrt(5.0*5.0 - 4.0*4.0) Math double 3.0

Math.random() Math double random in [0,1)

Math.round(3.14159) Math long 3

Typical expressions thatuseJava library methods

These APIs are typical of the online documentation that is the standard inmodern programming. There is extensive online documentation of the JavaAPIsthat is used by professional programmers, and it is available to you (if you are interested) directly from the Java website or through our booksite.You do not needto go to the online documentation to understand the code in this book or to writesimilarcode,because we present and explain in the text allof the library methodsthat weuse in APIs liketheseand summarize them in the endpapers. More important, in Chapters 2 and 3you willlearn in this book howto develop your own APIsand to implement functions for your own use.

Type conversion One of the primary rules of modern programming is that youshould always be awareof the type of data that your program is processing. Onlyby knowing the type can you know precisely which set of valueseach variable canhave, which literals you can use, and which operations you can perform. Typicalprogramming tasks involveprocessing multiple types of data, so we often need toconvert data from one type to another. There are several ways to do so in Java.

Explicit type conversion. You can use a method that takes an argument of onetype (the value to be converted) and produces a result of another type. We havealready used the Integer. parselnt () and Doubl e. parseDoubl e() library methods to convert String values to int and double values, respectively. Many othermethods are availablefor conversion among other types. For example, the librarymethod Math.round() takes a double argument and returns a long result: thenearest integer to the argument. Thus, for example, Math.round(3.14159) andMath. round (2.71828) are both of type long and have the same value (3).

Explicit cast. Java has some built-in type conversion conventions for primitivetypes that you can take advantage of when you are aware that you might lose infor-


mation.You haveto makeyour intention to do so explicitby usinga device calledacast. You cast an expression from one primitivetype to another by prepending thedesiredtype name within parentheses. For example, the expression (i nt) 2.71828is a cast from double to int that produces an int with value 2. The conversionmethods definedfor casts throw away information in a reasonable way (for a fulllist, see the booksite). For example, casting a floating-point number to an integerdiscards the fractionalpart by rounding towards zero. If you want a differentresult,suchas rounding to the nearestinteger, you must use the explicit conversion method Math. round (), as just discussed (but you then need to use an explicit cast toi nt, since that method returns a long). Randomlnt (Program 1.2.5) is an examplethat uses a cast for a practical computation.

Automatic promotion for numbers. You canuse data of anyprimitive numerictypewhere avalue whose typehasa larger range ofvalues isexpected, because Javaautomatically converts to the typewith the largerrange. Thiskind of conversion iscdHedpromotion. Forexample,weused numbers all of type doubl ein Program 1.2.3, so there is noconversion. If we had chosen to

make b and c of type i nt (usingInteger.parselntO to convert

the command-line arguments),automatic promotion would beused to evaluate the expressionb*b - 4.0*c. First, c is promoted to doubl e to multiply by thedoubl e literal 4.0, with a doubl e

result. Then, the i nt value b*b is

promoted to doubl e for the subtraction, leaving a doubl e result.Or, we might have written b*b -4*c. In that case,the expression b*b - 4*c would be evaluated as an i nt and thenthe result promoted to doubl e, because that is what Math. sq rt () expects. Promotion is appropriate because your intent is clear and it can be done with no loss of information. On the other hand, a conversion that might involve loss of information(for example, assigning a doubl e to an i nt) leads to a compile-time error.

expression expressiontype

expressionvalue

"1234" + 99 String "123499"

Integer.parselnt("123") int 123

(int) 2.71828 int 2

Math.round(2.71828) long 3

(int) Math.round(2.71828) int 3

(int) Math.round(3.14159) int 3

11 * 0.3 double 3.3

(int) 11 * 0.3 double 3.3

11 * (int) 0.3 int 0

(int) (11 * 0.3) int 3

Typical type conversions


y^j^^ u;

15

Im

Program 1.2.5 Casting to get a random integer

public class Randomlnt{


int N = Integer.parselnt(args[0]);double r = Math.randomO; // uniform between 0 and 1int n = (int) (r * N); // uniform between 0 and N-lSystem.out.pri ntln(n);

}}

This program uses theJava method Math. random() to generate a random number r in theinterval [0> l)y then multiplies r by thecommand-line argument Nto get a random numbergreater than orequalto 0 and less than N, then uses a castto truncate theresultto bean integern between 0 and N-l.

% javac Randomlnt.java

% java Randomlnt 1000548



WMmmm

Casting has higher precedence than arithmetic operations—any cast is applied tothe value that immediately follows it. For example, if we write i nt n = (i nt) 11* 0.3, the cast is no help: the literal 11 is alreadyan integer,so the cast (i nt) hasno effect. In this example, the compiler produces a possible loss of precisionerror messagebecause there would be a lossof precision in converting the resultingvalue (3.3) to an i nt for assignmentto n.The error ishelpfulbecausethe intendedcomputation for this code is likely (i nt) (11 * 0.3), which has the value 3, not3.3.

33


Beginning programmers tend to find typeconversion to be an annoyance, but experiencedprogrammers knowthat paying careful attention to data types is a keytosuccess in programming. It iswell worthyourwhile to takethe time to understandwhat type conversion is allabout. After you have written just a few programs, youwill understand that these rules help you to make your intentions explicit and toavoid subtle bugs in your programs.

Summary A data type is a set ofvalues and a set ofoperations on those values.Java has eight primitive data types: boolean, char, byte, short, i nt, 1ong, f 1oat,and double. In Java code,we use operators and expressions like those in familiarmathematical expressions to invoke the operationsassociated with each type.Theboolean type is for computingwith the logical values true and false; the chartype is the set of charactervalues that wetype;and the other sixare numeric types,for computingwith numbers. In this book, we most often use boolean, i nt, anddoubl e; we do not use short or f 1oat. Another data type that we use frequently,Stri ng, is not primitive, but Java has some built-in facilities for Stri ngs that arelike those for primitive types.

When programming in Java, we haveto be aware that everyoperation is defined only in the contextof its data type (so we may need type conversions) andthat all types can haveonly a finite number of values (so we may need to live withimprecise results).

The boolean type and its operations— &&, | |, and ! —are the basis for logical decision-making in Java programs,when used in conjunction with the mixed-type comparison operators ==, !=, <, >, <=, and >=. Specifically, we use bool eanexpressions to control Java's conditional (i f) and loop (for and whi 1e) constructs,which we will study in detail in the next section.

The numeric types and Java's libraries giveus the ability to use Javaas an extensive mathematical calculator.Wewrite arithmetic expressions using the built-inoperators +, -, *, /, and %along with Java methods from the Math library.Althoughthe programs in this section are quite rudimentary by the standards of what wewillbe able to do after the next section, this class of programs is quite useful in its ownright. You will use primitive types and basic mathematical functions extensivelyin Java programming, so the effort that you spend now understanding them willcertainly be worthwhile.


Q. What happens if I forget to declare a variable?

A, The compiler complains, as shown below for a program IntOpsBad, which isthe same as Program 1.2.2 except that the i nt variable p is omitted from the declaration statement.

% javac IntOpsBad.javaIntOpsBad.java:7: cannot resolve symbolsymbol : variable plocation: class IntOpsBadp = a * b;

A

IntOpsBad.java:10: cannot resolve symbolsymbol : variable plocation: class IntOpsBadSystem.out.println(a + " * " + b + " -

2 errors

+ p);A

The compiler says that there are two errors, but there is reallyjust one: the declaration of p is missing. If youforget to declare a variable that you use often, youwillget quite a fewerror messages. Agood strategyis to correctthefirst error and checkthat correction before addressing later ones.

Q. What happens if I forget to initialize a variable?

A. The compiler checks for this condition and will giveyou a variable mightnot have been i ni ti al i zed error message if you try to use the variable in anexpression.

Q. Is there a difference between = and == ?

A. Yes, they are quite different! The first is an assignment operator that changesthe value of a variable, and the second is a comparison operator that produces abool ean result.Yourability to understand this answer is a sure test of whether youunderstood the material in this section. Think about how you might explain thedifference to a friend.

35


Q. Why do i nt valuessometime become negative when they get large?

A, If you havenot experiencedthis phenomenon, seeExercise 1.2.10. The problemhas to do with the way integers are represented in the computer. You can learn thedetails on the booksite. In the meantime, a safestrategy is using the int type whenyou know the values to be lessthan ten digits and the 1ong type when you think thevalues might get to be ten digits or more.

Q. It seems wrong that Java should just let i nts overflow and give bad values.Shouldn't Java automatically check for overflow?

A. Yes, this issue is a contentious one among programmers. The short answer fornow is that the lack of such checking is one reason such types are calledprimitivedata types.A little knowledgecan go a long wayin avoiding such problems. Again,it is fine to use the i nt type for small numbers, but when values run into the billions, you cannot.

Q. What is the value of Math, abs (-2147483648)?

A. -2147483648.This strange (but true) result isa typicalexampleof the effects ofinteger overflow.

Q. It is annoyingto seeall those digitswhen printing a f 1oat or a double. Can weget System. out. pri ntl n() to print out just two or three digits after the decimalpoint?

A. That sort of task involves a closer look at the method used to convert from

double to String. The Java library function System.out.printf() is one wayto do the job,and it is similarto the basic printing method in the C programminglanguage and many modern languages, as discussed in Section 1.5. Until then, wewill live with the extra digits (which is not all bad, since doing so helps us to getused to the different primitive types of numbers).

Q. How can I initialize a double variable to infinity?

A, Java has built-in constants available for this purpose: Double.POSITIVE_IN-FINITY and Double.NEGATIVE INFINITY.


Q. What is the value of Math. round(6.022e23)?

A. You should get in the habit of typing in a tiny Java program to answer suchquestions yourself (and trying to understand why your program produces the result that it does).

Q. Can you compare a doubl e to an i nt?

A, Not without doing a type conversion, but remember that Java usuallydoes therequisite type conversionautomatically. For example, if x is an i nt with the value3, then the expression (x < 3.1) is true—Java converts x to doubl e (because 3.1is a doubl e literal) before performing the comparison.

Q. Are expressions like 1/0 and 1.0/0.0 legalin Java?

A. No and yes. The first generates a run-time exception for divisionby zero (whichstopsyour program becausethe valueis undefined); the secondis legaland has thevalue Infinity.

Q. Are there functions in Java's Math library for other trigonometric functions, likecosecant, secant, and cotangent?

A. No,becauseyou could use Math.si n(), Math.cos (), and Math.tan () to compute them. Choosingwhichfunctions to includein an API isa tradeoffbetweentheconvenience of having everyfunction that you need and the annoyance of havingto find one of the few that you need in a long list. No choicewill satisfyall users,and the Java designers have manyusers to satisfy. Notethat there are plentyof redundancies even in the APIs that we havelisted. For example,you could use Math.si n (x) /Math. cos (x) instead of Math. tan (x).

Q. Can you use < and > to compare Stri ngvariables?

A. No. Those operators are defined only for primitive types.

Q. How about == and != ?

A. Yes, but the result may not be what you expect, because of the meanings theseoperators have for non-primitive types. Forexample, thereisa distinction between


a String and its value. The expression "abcM == "ab" + x is false when x is aStri ng with value "c" because the two operands are stored in different places inmemory (even though they have the same value). This distinction is essential, asyou will learn when we discuss it in more detail in Section 3.1.

Q. What is the result of division and remainder fornegative integers?

A. The quotient a / b rounds toward 0;the remainder a % b is defined such that(a / b) * b + a % b is always equal to a. For example, -14/3 and 14/-3 areboth-4, but -14 % 3 is -2 and 14 % -3 is 2.

Q. Will (a < b < c) test whether three numbers are in order?

A. No, that will not compile.You need to say (a < b && b < c).

Q. Fifteen digits for floating-point numbers certainly seems enough to me. Do Ireally need to worry much about precision?

A. Yes, because you are used to mathematics based on real numbers with infiniteprecision, whereas the computer always deals with approximations. For example,(0.1 +0.1==0.2) is true but (0.1 +0.1 +0.1==0.3) is false! Pitfalls like thisare not at all unusual in scientific computing. Novice programmers should avoidcomparingtwo floating-point numbers for equality.

Q. Why do we say (a && b) and not (a & b)?

A. Java also has a&operator thatwe do not use in this book but which you mayencounter if you pursueadvanced programming courses.

Q. Why is the value of 10A6 not 1000000but 12?

A. The a operator is not an exponentiation operator, which you must havebeenthinking. Instead, it is an operatorlike &that we do not use in this book. You wanttheliteral le6. You could also use Math. pow(10, 6) but doing soiswasteful if youareraising10 to a known power.


1.2.1 Suppose that a and b are i nt values.What does the following sequence ofstatements do?

int t = a; b=t; a=b;

1.2.2 Write a program that uses Math. si n() and Math. cos () to check that thevalue of cos2 0 + sin2 6 is approximately 1for any 0 entered as a command-line argument. Just print the value.Why are the values not always exactly 1?

1.2.3 Suppose that a and b are i nt values. Show that the expression

(!(a && b) && (a || b)) || ((a && b) || !(a || b))

is equivalent to true.

1.2.4 Suppose that a and b are i nt values. Simplify the following expression:(!(a < b) && !(a > b)).

1.2.5 The exclusive or operator a for boolean operands is defined to be true ifthey are different, fal se if they are the same. Givea truth table for this function.

1.2.6 Why does 10/3 give 3 and not 3.333333333?

Solution. Sinceboth 10 and 3 are integer literals,Java seesno need for type conversion and usesinteger division.You should write 10.0/3.0 ifyou mean the numbersto be doubl e literals. If you write 10/3.0 or 10.0/3, Javadoes implicit conversionto get the same result.

1.2.7 What do each of the following print?a. System.out.println(2 + "be");

b. System.out.println(2 + 3 + "be")

c. System.out.println((2+3) + "be")

d. System.out.println("bc" + (2+3))

e. System, out. pri ntl n("be" + 2 + 3)

Explain each outcome.


1.2.8 Explain how to use Program 1.2.3to find the square root of a number.

1.2.9 What do each of the followingprint?a. System.out.printlnC'b1);

b. System.out.pn'ntln(fbf + 'c');

c. System.out.println((char) ("a1 + 4));


1.2.10 Suppose that a variable a is declared as i nt a = 2147483647 (or equiva-lently, Integer. MAX_VALUE). What do each of the following print?

a. System.out.println(a);

b. System.out.print!n(a+l);

c. System.out. pri ntln(2-a);

d. System.out.println(-2-a);

e. System. out. pri ntl n (2*a);

/ System.out.pri ntln(4*a);


1.2.11 Suppose that a variable a isdeclared as double a = 3.14159. What do eachof the followingprint?

a. System, out. println (a);

b. System, out. pri ntl n(a+l);

c. System.out.println(8/(int) a);

d. System.out.println(8/a);

e. System. out. pri ntl n ( (i nt) (8/a));


1.2.12 Describewhat happens ifyou write sq rt instead of Math. sq rt in Program1.2.3.

1.2.13 What is the value of (Math. sqrt (2) * Math. sqrt (2) == 2)


1.2.14 Write a program that takes two positive integers as command-line arguments and prints true if either evenlydivides the other.

1.2.15 Write a program that takes three positive integers as command-line arguments and prints t rue if any one of them is greater than or equal to the sum of theother two and false otherwise. (Note: This computation tests whether the threenumbers could be the lengths of the sides of some triangle.)

1.2.16 A physics student gets unexpected results when using the code

F = G * massl * mass2 / r * r;

to compute values according to the formula F = Gmxm21 r2. Explain the problemand correct the code.

1.2.17 Give the value of a after the execution of each of the following sequences:

int a = 1;a = a + a;

a = a + a;

a = a + a;

boolean a = true;a = !a;a = !a;a = !a;

int a = 2;a = a * a;a = a * a;a = a * a;

1.2.18 Suppose that x and y are doubl e values that represent the Cartesian coordinates of a point (x,y) in the plane. Givean expression whose value is the distanceof the point from the origin.

1.2.19 Write a program that takes two i nt values a and b from the command lineand prints a random integer between a and b.

1.2.20 Write a program that prints the sum of two random integers between 1 and6 (such as you might get when rolling dice).

1.2.21 Write a program that takes a double value t from the command line andprints the value of sin(2t) + sin(3t).

1.2.22 Write a program that takes three doubl e valuesx0, v0, and t from the command line and prints the value of x0 + v0t + gt2/2, where g is the constant 9.78033.(Note: This value the displacement in meters after t seconds when an object isthrown straight up from initial position x0 at velocity v0 meters per second.)

1.2.23 Writea program that takes two i nt values mand d from the command lineand prints true if day d of month m is between3/20 and 6/20, f al se otherwise.


Creativ&ixeKcises

1.2.24 Loan payments. Write a program that calculates the monthly paymentsyou would have to make over a givennumber of years to pay off a loan at a giveninterest rate compounded continuously,taking the number of years t, the principalP, and the annual interest rate r as command-line arguments. The desired value isgiven by the formula Pen. Use Math. exp().

1.2.25 Wind chill. Given the temperature t (in Fahrenheit) and the wind speed v(in miles per hour), the National Weather Service defines the effective temperature(the wind chill) to be:

w = 35.74 + 0.6215 t + (0.4275 t - 35.75) v0-16

Write a program that takes two double command-line arguments t and v andprints out the wind chill.UseMath.pow(a, b) to compute ab. Note:The formula isnot valid if t is larger than 50 in absolute value or if v is larger than 120or less than3 (you may assume that the valuesyou get are in that range).

1.2.26 Polar coordinates. Write a program that converts from Cartesian to polar coordinates.Your program should take two real numbers x and y on the command line and print the polar coordinates rand 0. Use the Javamethod Math.atan2 (y, x) which computes thearctangent value ofy/x that is in therange from -ir to it. Polar coordinates

1.2.27 Gaussian random numbers. One way to generate a randomnumber taken from the Gaussian distribution is to use the Box-Muller formula

w = sin(2iTv) (-2lnt/)1/2

where u and v are real numbers between 0 and 1 generated by the Math. random ()method. Write a program StdCaussian that prints out a standard Gaussian random variable.

1.2.28 Order check. Write a program that takes three double values x, y, and zas command-linearguments and prints true if the values are strictlyascending ordescending (x<y <zorx>y>z),and false otherwise.

1.2.29 Dayof the week. Writea program that takesa date as input and prints theday of the week that date falls on. Your program should take three command line


parameters: m(month), d (day), and y (year). For m, use 1 for January, 2 for February, and so forth. For output, print 0 for Sunday, 1 for Monday, 2 for Tuesday, andso forth. Use the following formulas, for the Gregorian calendar:

y0 =y-(U-m)l\2* =y0 + ro/4-Vioo+V4()om0 = m + 12 X ((14 - m) 112) - 2d0 = (d + x+(31Xm0)/12)%7

Example: On what day of the weekwas February 14,2000?

y0 = 2000 - 1 = 1999x = 1999 + 1999/4 - 1999/100 + 1999/400 = 2483

m0= 2 + 12X1 -2 = 12d0 = (14 + 2483 + (31X12) /12) % 7 = 2500% 7 = 1

Answer: Monday.

1.2.30 Uniform random numbers. Write a program that prints five uniform random values between 0 and 1, their average value, and their minimum and maximum value. Use Math. random (), Math. min(), and Math. max().

1.2.31 Mercatorprojection. The Mercatorprojection is a conformal (angle preserving) projection that maps latitude 9 and longitude X to rectangular coordinates(x,y). It is widely used—for example, in nautical charts and in the maps that youprint from the web. The projection is defined by the equations x = X —X0 andy = 1/2 In ((1 + sincp) / (1 —sincp)), where X0 is the longitude of the point in thecenter of the map. Write a program that takes \0 and the latitude and longitude ofa point from the command line and prints its projection.

1.2.32 Color conversion. Several different formats are used to represent color. Forexample, the primary format for LCD displays, digital cameras, and web pages,known as the RGB format, specifies the level of red (R), green (G), and blue (B)on an integer scale from 0 to 255. The primary format for publishing books andmagazines, known as the CMYKformat, specifies the level of cyan (C), magenta(M), yellow (Y), and black (K) on a real scale from 0.0 to 1.0.Write a program RG-BtoCMYK that converts RGB to CMYK. Take three integers—r, g, and b—from the


command line and print the equivalent CMYK values. If the RGB values are all 0,then the CMY values are all 0 and the K value is 1; otherwise, use these formulas:

w = max(r/255,g/255,b/255)c = (w-(r/255))/wm = (w-(g/255)) Iwy = (w-(fo/255)) Iwk = 1 — w

1.2.33 Great circle. Write a program GreatCi rcl e that takes four command-linearguments—xl, yl, x2, and y2—(the latitude and longitude, in degrees, of twopoints on the earth) and prints out the great-circle distance between them. Thegreat-circle distance (in nautical miles) is givenby the equation:

d = 60 arccos(sin(x1) sin(x2) + cos^) cos(x2) cos(yx —y2))

Note that this equation uses degrees, whereas Java's trigonometric functions useradians. Use Math.toRadiansO and Math.toDegreesO to convert between thetwo. Use your program to compute the great-circle distance between Paris (48.87°N and -2.33° W) and San Francisco (37.8° N and 122.4° W).

1.2.34 Three-sort. Write a program that takesthree int values from the commandline and prints them in ascending order. UseMath.mi n() and Math. max ().

1.2.35 Dragon curves. Write a program to printthe instructions for drawing the dragon curves oforder 0 through 5. The instructions are strings ofF, L, and R characters, where F means "draw linewhile moving 1 unit forward,'' L means "turn left,"and Rmeans "turn right." A dragon curve of orderN is formed when you fold a strip of paper in half Ntimes, then unfold to right angles.The keyto solvingthis problem is to note that a curve of order N is acurve of order N— 1 followed by an Lfollowed by acurve of order N— 1 traversed in reverse order, andthen to figure out a similar description for the reverse curve

j

b

FLF

FLFLFRF

FLFLFRFLFLFRFRF

Dragoncurves of order 0, ly2, and 3


1.3 Conditionals and Loops

In the programsthat we haveexamined to this point, each of the statements in theprogram is executedonce,in the order given. Most programs are more complicatedbecause the sequence of statements and the number of times each is executed canvary.Weuse the term controlflow to refer to statement sequencing in a program. Inthis section, we introduce statements that

allowus to changethe control flow, using 1.3.1 Flipping afair coin 49logic about the values of program vari- 1.3.2 Your first while loop 51ables. This feature is an essential compo- L3'3 Computing powers of two 53

r . 1.3.4 Your first nested loops 59nent ofprogramming. 135 Harmonic numbers 61

Specifically, we consider Java state- L3.6 Newton's method 62ments that implement conditionals, where 1.3.7 Converting tobinary 64some other statements may or may not L3-8 Gambler's ruin simulation 66be executed depending on certain condi- L3'9 Factoring integers 69tions, and loops, where some other state- Programs in this sectionments may be executed multiple times,again depending on certain conditions. As you will see in numerous examples inthis section, conditionals and loops truly harness the power of the computer andwill equip you to write programs to accomplish a broad variety of tasks that youcould not contemplate attempting without a computer.

If statements Most computations require differentactions for different inputs.One way to express these differencesin Javais the i f statement:

if (<boolean expression) { <statements> }

This description introduces a formal notation known as a template that we willuse to specifythe format of Java constructs. We put within angle brackets (< >) aconstruct that we have alreadydefined, to indicate that we can use any instance ofthat construct where specified. In this case, <boolean expression> represents anexpression that has a boolean value, such as one involving a comparison operation,and <statements> represents a statement block (a sequence of Java statements,each terminated by a semicolon). This latter construct is familiar to you: the bodyof mai n() is such a sequence.If the sequence is a single statement, the curly bracesare optional. It is possible to make formal definitions of <boolean expressionand <statements>> but werefrainfrom goinginto that level of detail.The meaning


of an i f statement is self-explanatory: the statement(s) in the sequence are to beexecuted if and only if the expressionis true.

Asa simple example,suppose that you want to compute the absolute value ofan i nt value x. This statement does the job:

47

if (x < 0) x = -x;

As a second simple example, consider the followingstatement:

if (x > y){

int t = x;x = y;

y = t;

}

booleanexpression

\

{

z (|x > y|)

•

ts

int t = x;x = y;y = t;

sequence

statements

}

Anatomyof an i f statement

This code puts x and y in ascending order by exchangingthem ifnecessary.

You can also add an el se clause to an i f statement, to express the concept ofexecutingeither one statement (or sequenceof statements) or another, dependingon whether the boolean expression is true or f al se, as in the following template:

if (<boolean expression^ <statements T>else <statements F>

As a simple example of the need for an el se clause, consider the following code,which assigns the maximum of two i nt values to the variable max:

if (x > y) max = x;else max = y;

One way to understand control flow is to visualize it with a diagram called a flowchart. Paths through the flowchartcorrespond to flow-of-controlpaths in the pro-

if (x < 0) x = -x;

yf-d\

< 0 ?

-x;


\yes / r\ no

max = x;

—czzmax = y;

zzi—

Flowchartexamples (i f statements)

48

absolute value

putx andyinto

sorted order

maximum ofx andy

error check

for divisionoperation

error check

for quadraticformula

if (x < 0) x = -x;

if (x > y){

int t = x;y = x;

x = t;

}



if (den == 0) System.out.println("Division by zero");else System.out.println("Quotient = " + num/den);

double discriminant = b*b - 4.0*c;if (discriminant < 0.0){

System.out.println("No real roots");}else

{System.out.println((-b + Math.sqrt(discriminant))/2.0);System.out.println((-b - Math.sqrt(discriminant))/2.0);

}

Typical examples of using i f statements

gram. In the earlydaysof computing,when programmers used low-level languagesand difficult-to-understand flows of control, flowcharts were an essential part ofprogramming.With modern languages, we use flowcharts just to understand basicbuilding blocks like the i f statement.

The accompanying table contains some examples of the use of i f and i f-el se statements.These examples are typicalof simple calculationsyou might needin programs that you write. Conditional statements are an essential part of programming. Since the semantics (meaning) of statements likethese is similar to theirmeanings as natural-language phrases, you will quickly grow used to them.

Program 1.3.1 is another example of the use of the if-else statement, inthis case for the task of simulating a coin flip. The body of the program is a singlestatement, like the ones in the table above, but it is worth special attention becauseit introduces an interesting philosophical issue that is worth contemplating: can acomputer program produce random values?Certainly not, but a program can produce numbers that have many of the properties of random numbers.


^^^^^^^M

|§j Program 1.3.1 Flipping afair coin

public class Flip{

public static void main(String[] args){ // Simulate a coin flip.

if (Math.randomO < 0.5) System.out.println("Heads");else System.out.pri ntln("TaiIs");

}}

This program uses Math. random () to simulate a coin flip. Each time you run it, itprints eitherheads ortails. A sequence offlips will have many ofthe same properties asa sequence that youwould getbyflipping afair coin, hut it is not a truly random sequence.

Many computations areinherently repetitive. The basic Java construct for handlingsuch computationshasthe following format:

while (<boolean expression} { <statements> }

The whi 1e statementhasthe sameformasthe i f statement(the only difference being the use of the keywordwhi 1e instead of i f), but the meaningis quite different.It is an instruction to the computer to behave as follows: if the expression is f al se,do nothing; if the expression is true, execute the sequence of statements (just aswith i f) but then check the expression again, execute the sequence of statementsagain if the expression is true, and continue aslong as the expression is true. Weoften refer to the statementblock in a loop as the body of the loop.As with the i fstatement, the braces areoptional if a whi1e loop body has just one statement.The whi1e statement is equivalent to a sequence of identical i f statements:

49


if (<boolean expression^if (<boolean expression^if Q<boolean expression^

{ <statements> }{ <statements> }{ <statements> }

initialization is aseparate statement

int v

while

loopcontinuation

condition

= i; /(|v <= N/21)

braces are foptional ^

whenbodyis asingle ^statement

At some point, the code in one of the statements mustchange something (such as the value of some variable inthe boolean expression) to make the boolean expressionf al se, and then the sequence is broken.

A common programming paradigm involves maintaining an integervalue that keeps track of the number oftimes a loop iterates. We start at some initial value, and then increment the valueby 1 eachtime through the loop,testingwhether it exceeds a predetermined maxi

mum before deciding to continue. TenHellos(Program 1.3.2) is a simple example of this paradigm that usesa whi 1e statement. The keyto thecomputation is the statement

}

v = 2*v;

tbody

Anatomy of a whi1e loop

int i = 4;

while (i <

{System.out.pri ntln(ii = i + 1;

10)

+ "th Hello");

= 4;

.(i <= io ? y\yes

System.out.println(i + "th Hello");

_Li + 1;

zi

fFlowchart example (whilestatement)

i = i +1;

As a mathematical equation, this statement isnonsense, but as a Java assignment statement itmakesperfect sense: it saysto compute the valuei + 1 and then assignthe result to the variable i.If the value of i was 4 before the statement, it be

comes 5 afterwards; if it was 5 it becomes 6; andso forth. With the initial condition in TenHel 1 os

that the value of i starts at 4, the statement block

is executed five times until the sequence is broken, when the value of i becomes 11.

Using the whi 1e loop is barelyworthwhile for this simple task, but you willsoon be addressing tasks where you will need to specifythat statements be repeatedfar too many times to contemplate doing it without loops. There is a profounddifference between programs with whi 1e statements and programs without them,because while statements allow us to specify a potentially unlimited number ofstatements to be executed in a program. In particular, the whi1e statement allowsus to specify lengthy computations in short programs. This ability opens the doorto writing programs for tasks that we could not contemplate addressing without a


Program 1.3.2 Yourfirst while loop

public class TenHellos{

public static void main(String[] args){ // Print 10 Helios.

System.out.pri ntln("1st Hel1o");System.out.println("2nd Hello");System.out.println("3rd Hello");int i = 4;while (i <= 10){ // Print the ith Hello.

System.out.println(i + "th Hello");i = i + 1;

}}

This program uses a while loop for the simple, repetitive task of printing the output shownbelow. After the third line, the lines to be printed differ only in the value of the index countingthe line printed, so we define a variable i to contain that index. After initializing the value ofi to 4, weenter into a whi 1e loop where we use the value ofi in the System. out .pri ntl n()statement and increment it each time through the loop. After printing 10th Hel 1o, the valueofi becomes 11 and theloop terminates.

% Java TenHellos1st Hello

2nd Hello

3rd Hello

4th Hello

5th Hello

6th Hello

7th Hello

8th Hello

9th Hello

10th Hello

>immm

I

4

5

6

7

8

9

10

11

i <= 10

true

true

true

true

true

true

true

false

output

4th Hello

5th Hello

6th Hello

7th Hello

8th Hello

9th Hello

10th Hello

Trace ofj ava TenHel 1os

51


computer. But there is also a price to pay: as your programs become more sophisticated, they become moredifficult to understand.

PowersOfTwo (Program 1.3.3) uses a while loopto print out a table of the powers of 2. Beyondthe loopcontrol counter i, it maintains a variable v that holdsthe powersof two as it computes them. The loop bodycontains three statements: one to print the currentpower of 2, one to compute the next (multiply the current one by 2), and one to increment the loop controlcounter.

There are many situations in computer sciencewhere it is useful to be familiar with powers of 2. Youshould know at least the first 10 values in this table

and you should note that 210 is about 1 thousand, 220 isabout 1 million, and 230 is about 1 billion.

PowersOfTwo is the prototype for many useful computations. By varying the computations thatchange the accumulated value and the way that theloop control variable is incremented, we can print outtablesof a varietyof functions (seeExercise 1.3.11).

It is worthwhile to carefullyexamine the behavior of programs that use loops by studying a trace ofthe program. For example, a trace of the operation ofPowersOfTwo should show the value of each variable

before each iteration of the loop and the value of theconditional expression that controls the loop. Tracing the operation of a loop can be very tedious,but itis nearly always worthwhile to run a trace because itclearly exposes what a program is doing.

PowersOfTwo is nearly a self-tracing program,because it prints the values of its variables each timethrough the loop. Clearly, you can make any programproduce a trace of itselfby adding appropriate System.out. pri ntl n() statements. Modern programming environments provide sophisticated tools for tracing, but

i <= N

0 1 true

1 2 true

2 4 true

3 8 true

4 16 true

5 32 true

6 64 true

7 128 true

8 256 true

9 512 true

10 1024 true

11 2048 true

12 4096 true

13 8192 true

14 16384 true

15 32768 true

16 65536 true

17 131072 true

18 262144 true

19 524288 true

20 1048576 true

21 2097152 true

22 4194304 true

23 8388608 true

24 16777216 true

25 33554432 true

26 67108864 true

27 134217728 true

28 268435456 true

29 536870912 true

30 1073741824 false

Trace of jawa PowersOfTwo 29

13 Conditionals and Loops 53

Program 1.3.3 Computingpowers of two

public class PowersOfTwo{

public static void main(String[] args){ // Print the first N powers of 2.

int N = Integer.parselnt(args[0]);int v = 1;int i = 0;while (i <= N){ // Print ith power of 2.

System.out,println(i + "v = 2 * v;i = i + 1;

loop termination value

loop control counter

current powerof 2

8IS

''^*$!5sSli£^CT

+ v);

}}

This program takes a command-line argument Nand prints a table ofthe powers of2 that areless than or equal to 2N. Each time through the loop, we increment the value ofi and doublethe value ofv. We show only the first three and the last three lines of the table; the programprints N+l lines.

% Java PowersOfTwo 50 1

1 2

2 4

3 8

4 16

5 32

i

'"^^p^^^^^^^^w^^^^^^^^^^^

% Java PowersOfTwo 290 1

1 2

2 4

27 134217728

28 268435456

29 536870912

$

l

"^^^^^^J^^^^fif^^??^ SlWHfSSFS^Sp^Sgi^B^aKj

this tried-and-true method is simple and effective. You certainly should add printstatements to the first fewloops that you write,to be surethat they are doing preciselywhat you expect.

There is a hidden trap in PowersOfTwo, because the largest integer in Java'si nt data type is 231 - 1 and the program does not test for that possibility. If you


invoke it with Java PowersOfTwo 31, you may be surprised by the last line ofoutput:

1073741824

-2147483648

The variable v becomes too large and takeson a negative valuebecause of the wayJava represents integers. The maximum value of an i nt is available for us to use asInteger. MAX_VALUE. A better version of Program 1.3.3would use this value to testfor overflow and print an error message if the user types too large avalue,thoughgetting sucha program to work properly for all inputs is trickier than you mightthink. (Fora similar challenge, seeExercise 1.3.14.)

As a more complicated example, suppose that wewant to compute the largest power of two that is lessthan or equal to a given positive integer N. If Nis 13 wewant the result 8; if Nis 1000, we want the result 512; if Nis 64, we want the result 64;and so forth. This computation is simple to perform with awhi1e loop:

int v = 1;while (v <= N/2)

v = 2*v;

It takes some thought to convince yourself that this simple pieceof code produces the desired result. You can doso by making these observations:

• v is always a power of 2.• v is never greaterthan N.• v increases each time through the loop, so the loop

must terminate.

• After the loop terminates, 2*v is greater than N.Reasoning of this sort is often important in understandinghow whi1e loops work.Even though many of the loops you will write aremuch simpler than this one, youshould be sure to convince yourself that eachloop you write is going to behave asyou expect.

The logic behind such arguments is the same whether the loop iterates justa few times, as in TenHellos, dozens of times, as in PowersOfTwo, or millions oftimes, as in severalexamples that we will soon consider. That leap from a few tinycasesto a huge computation is profound. When writing loops, understanding how

*int v = 1;

\

rcv <= N/2 ?

""Xrto

jf yes

v = 2*v;

i

r

Flowchart for the statementsint v = 1;while (v <= N/2)

v = 2*v;


the values of the variables change each time through the loop (andchecking thatunderstanding by adding statements to trace theirvalues and running for a smallnumber of iterations) is essential. Having done so, you can confidently removethosetrainingwheels and trulyunleash the power of the computer.

For loops As you will see, the whi 1e loop allows us to write programs for allmanner of applications. Before considering more examples, wewill look at an alternate Java construct that allows us evenmore flexibility when writing programswith loops. This alternate notation is not fundamentally different from the basicwhi 1e loop, but it is widely used because it often allows us to write more compactand more readableprograms than if we used onlywhi 1e statements.

Fornotation. Manyloops follow this scheme: initialize an indexvariable to somevalue and then use a while loop to test a loop continuation condition involvingthe indexvariable, wherethe last statementin the whi 1e loop incrementsthe indexvariable. You can express such loops directly with Java's for notation:

for (<initialize>m, <boolean expression>; <increment>){

<statements>

}

This code is,with only a fewexceptions, equivalent to

<initialize>;while (<boolean expression^{

<statements>

<increment>m,}

Your Java compiler might evenproduce identicalresultsfor the two loops. In truth,<initia 7ize> and <increment> canbe anystatements at all, but wenearlyalwaysusefor loopsto support this typical initialize-and-increment programmingidiom.For example, the following two lines of codeare equivalent to the correspondinglines of code in TenHellos (Program 1.3.2):

for (int i = 4; i <= 10; i = i + 1)System.out.println(i + "th Hello");

55


Typically, we work with a slightly more compact version of this code, using theshorthand notation discussed next.

Compound assignment idioms. Modifying the value of a variable is somethingthat wedo so oftenin programming that Java provides a varietyof different shorthand notations for the purpose.For example, the following four statementsall increment the value of i by 1 in Java:

i = i + 1; i ++; ++i; i += 1;

You canalso say i -- or --i or i -= 1 or i = i -1 to decrementthat value of i by 1.Mostprogrammers usei ++ or i -- in for loops, thoughanyof the otherswoulddo.The ++ and -- constructs are normally used for integers,but the compound assignmentconstructs are useful operations for any arithmetic operator in any primitivenumerictype. Forexample, youcansay v *= 2 or v += v instead of v = 2*v. Allof these idioms are for notational convenience, nothing more. This combination ofshortcuts cameinto widespreadusewith the C programming languagein the 1970sand havebecomestandard.Theyhavesurvivedthe test of time becausethey lead tocompact, elegant, and easily understood programs. When you learn to write (andto read) programsthat use them,youwill be ableto transfer that skill to programming in numerous modern languages, not just Java.

Scope. The scope of a variable is the part of the programwhereit is defined. Generally the scope of a variable is comprised of the statements that follow the declaration in the same block as the declaration. For this purpose, the code in the forloop header is consideredto be in the sameblock as the for loop body. Therefore,the whi 1e and for formulations of loops are not quite equivalent: in a typical forloop, the incrementing variable is not available for use in later statements; in thecorresponding whi 1e loop, it is. This distinction is often a reason to use a whi 1einstead of a for loop.

Choosing among different formulations of the same computation is a matter ofeachprogrammer's taste,aswhen a writer picksfrom among synonymsor choosesbetween using active and passive voice when composing a sentence.You will notfind good hard-and-fast rules on how to compose a program any more than youwill find such rules on how to compose a paragraph. Your goal should be to find astylethat suits you, getsthe computation done, and can be appreciated by others.


The accompanying tableincludesseveral code fragments with typicalexamples of loops used in Java code.Some of these relate to code that youhave alreadyseen;others arenew codefor straightforward computations. Tocement your understanding of loopsin Java, put these code snippets into aclass's code that takesan integerNfromthe command line (like PowersOfTwo)and compileand run them.Then, writesome loops of your own for similar computations of your own invention, or dosome of the earlyexercises at the end of this section.There is no substitute for theexperience gained by running code that you create yourself, and it is imperativethat you develop an understanding of howto writeJava code that uses loops.

initialize anothervariable in a

separate .statement^.

declare and initializea loopcontrolvariable

\ l00P\ continuation\ condition increment

int v =1;\ | /for (|int i = Ofc |i <= Nfc [i++~l){

print largest powerof twoless than orequaltoN

compute afinite sum(1+2 + ...+N)

compute afiniteproduct(N! = 1x2 x ... x N)

printa table offunction values

print the rulerfunction(seeProgram 1.2.1)

}

System.out.pri ntln(iv = 2*v;

tbody

+ v);

Anatomy ofa for loop (thatprintspowers of2)

int v = 1;while (v <= N/2)

v = 2*v;System.out.pri ntln(v);

int sum = 0;for (int i = 1; i <= N; i++)

sum += i;System.out.pri ntln(sum);

int product = 1;for (int i = 1; i <= N; i++)

product *= i;System.out.pri ntln(product);

for (int i = 0; i <= N; i++)System.out.println(i + " ' + 2*Math.PI*i/N);

String ruler = " ";for (int i = 1; i <= N; i++)

ruler = ruler + i + ruler;System.out.pri ntln(ruler);

Typical examples of usingfor and whi 1e statements


Nesting The i f, whi1e, and for statements have the same status as assignmentstatements or any other statements in Java. That is, we can use them whenever astatement is called for. In particular,we can use one or more of them in the <body>of another to make compound statements. As a first example, DivisorPattern(Program 1.3.4) has a for loop whose statements are a for loop (whose statementis an i f statement) and a print statement. It prints a pattern of asterisks where theith row has an asterisk in each position corresponding to divisors of i (the sameholds true for the columns).

To emphasize the nesting,we use indentation in the program code.We referto the i loop as the outer loop and the j loop as the inner loop.The inner loop iteratesall the waythrough for eachiterationof the outer loop.Asusual, the best wayto understand a new programming construct like this is to study a trace.

Di vi sorPattern has a complicatedcontrol structure, as you can seefrom itsflowchart. A diagram like this illustrates the importance of using a limited number of simple control structures in programming. With nesting, you can composeloopsand conditionals to buildprograms that are easy to understandeven thoughtheymayhave a complicated controlstructure. A greatmanyuseful computationscan be accomplished with just one or twolevels of nesting.For example, manyprograms in this book havethe samegeneralstructure as Di vi sorPattern.

i = i;

T7}—»( i <= N?)

\ yes

j = i;

Tj++; [_^( j <= N?y

\ yes

>!L((i %j == 0) || (j %i == 0) ?yz

System.out.print("* "); System.out.print(" ");

System.out.pri ntln(i);I

I

Flowchart for Di vi so rPattern


&fiffl£^^

Program 1.3.4 Your first nested loops

public class DivisorPattern{

public static void main(String[] args){ // Print a square that visualizes divisors,

int N = Integer.parselnt(args[0]);for (int i = 1; i <= N; i++){ // Print the ith line

for (int j = 1; j <= N; j++){ // Print the jth entry in the ith line,

if ((i % j ==0) || (j % i == 0))System.out.print("* ");

else

System.out.print("

}

}System.out.pri ntln(i);

");

59

iL^£&?\&.-irt •}•'>$&£ 1' ""'

number of rowsand columns

row index

column index

'•mmmmmk V|P J^Bp^sP^

m

ii

1

m

This program takes an integer Hasthe command-line argument and uses nested for loops toprintan H-by-H table with an asterisk in row i andcolumn j if either i divides j or j dividesi. The loop control variables i and j control the computation.

% Java DivisorPattern 3* * * i

* * 2

* * 3

% Java DivisorPattern 16

* * 2

* 3

* 4

* 5

6

* 7

* 8

9

10

11

12

* 13

* 14

* 15

* 16

* * *

* * *

* *

* * *

*

* * *

* *

* * *

*

* * * *

* *

* * *

* *

*

*

I

4jjyjujim^ J^s*£B^ft<8»5immmmmmmsF

i j i % j j % i

1 1

1 2

1 3

2 1

2 2

2 3

3 1

3 2

3 3

0

0

0

1

0

1

1

2

0

output

Trace of Java DivisorPattern 3

i


As a second example of nesting, consider the following program fragment,which a tax preparation programmight use to compute income tax rates:

if (income < 0) rate = 0.0;

else if (income < 47450) rate = .22;


else if (income < 174700) rate « .28;


else rate = .35;

In this case, a number of i f statements are nested to test from among a numberof mutually exclusive possibilities. Thisconstruct isaspecial one thatweuseoften.Otherwise, it is best to use braces to resolve ambiguities when nesting i f statements. This issueand more examples are addressed in the Q&A and exercises.

Applications Theability to program withloops immediately opens up the fullworld of computation. To emphasize this fact, wenext consider avariety of examples. These examples all involve working withthe types of data thatweconsideredin Section 1.2, but rest assured that the same mechanisms serve us well for anycomputational application. The sample programs are carefully crafted, and bystudying andappreciating them, youwillbe prepared to writeyourown programscontaining loops, as requested in manyof the exercises at the end of this section.

The examples that we consider here involve computing with numbers. Several of our examples are tied to problems faced by mathematicians and scientiststhroughout the past several centuries. While computers have existed for only 50years or so, many of the computational methods thatwe use are based on a richmathematical tradition tracingback to antiquity.

Finite sum. The computational paradigm used by PowersOfTwo is one that you willuse frequently. It uses two variables—oneas an index that controls a loop and the other to accumulate acomputational result. Harmonic (Program 1.3.5) uses the sameparadigm to evaluate the finite sum HN = 1 + 1/2 + 1/3 + ... +1/N. These numbers, which are known as the Harmonic numbers, arise frequently in discrete mathematics. Harmonic numbers are the discreteanalog of the logarithm. They also approximate the area under the curvey = l/x.You can use Program 1.3.5 asa model for computing the values of other sums (seeExercise 1.3.16).

Trrm


Program 1.3.5 Harmonic numbers

public class Harmonic{

public static void main(String[] args){ // Compute the Nth Harmonic number.

int N = Integer.parselnt(args[0]);double sum = 0.0;for (int i = 1; i <= N; i++){ // Add the ith term to the sum

sum += 1.0/i;

}System.out.pri ntln(sum);

}}

N

i

sum

61

number of terms in sum

loop index

cumulated sum

-^mmmmmmmmmmmm

Thisprogram computes the value ofthe NthHarmonic number. The value isknownfrom mathematical analysis to beabout ln(N) + 0.57721 for large N. NotethatIn(lOOOO) ~ 9.21034.

% Java Harmonic 21.5

% Java Harmonic 102.9289682539682538

% Java Harmonic 100009.787606036044348

Hi

I

1

Computing the square root. How are functions in Java's Math library,such as Math. sqrt (), implemented? Sqrt (Program 1.3.6)illustrates one technique. To compute the square root function, ituses an iterativecomputation that wasknown to the Babyloniansover 4,000 years ago. It is also a special case of a general computational technique that was developed in the 17th century byIsaac Newton and Joseph Raphson and is widely known as Newton's method. Under generous conditions on a given function/(x),Newton's method is an effective way to find roots (values of x forwhich the function is0). Startwith an initialestimate, t0. Given the

j^^S^f^

y=f(x)-

Newtons method


Program 1.3.6 Newton's method

m

mm

public class Sqrt{


double c = Double.parseDouble(args[0]);double epsilon = le-15;double t = c;while (Math.abs(t - c/t) > epsilon * t){ // Replace t by the average of t and c/t

t = (c/t + t) / 2.0;

}System.out.pri ntln(t);

argument

error tolerance

estimate ofc

}y

This program computes thesquare root ofitscommand-line argument to 15 decimal places ofaccuracy, using Newton's method (see text).

% Java Sqrt 2.01.414213562373095

% Java Sqrt 25445451595.1630010754388

4»»yji wmwmf?

estimate tiy computea new estimate bydrawing a line tangent to the curve y-fix) at the point (*,-,/(*,•)) and set ti+l to the x-coordinate of the point where thatline hits the x-axis. Iterating this process,we get closer to the root.

Computing the squareroot of a positive number c is equivalent to finding thepositive root of the function f(x) = x2 - c. For this special case, Newton's methodamounts to the process implemented in Sqrt (see Exercise 1.3.17). Start with theestimate t = c. If tis equal to c/t, then t is equal to the square root of c, so the computation is complete. If not, refine the estimate by replacing t with the average of t

iteration

2.0000000000000000

1 1.5000000000000000

2 1.4166666666666665

3 1.4142156862745097

4 1.4142135623746899

5 1.4142135623730950

1.0

1.3333333333333333

1.4117647058823530

1.4142114384748700

1.4142135623715002

1.4142135623730951

JWMWW

Trace of Java Sqrt 2,mmmmmmmmmmmmm

o

!


and c/t.With Newton's method, we get the value of thesquare root of 2 accurate to 15placesin just 5 iterationsof the loop.

Newton's method is important in scientificcomputing because the same iterative approach is effective for finding the roots of a broad class of functions,including many for which analytic solutions are notknown (so the Java Math library would be no help).Nowadays, we take for granted that we can find whatever values we need of mathematical functions; beforecomputers, scientists and engineers had to use tables orcomputed values by hand. Computational techniquesthat were developed to enable calculations by handneeded to be very efficient, so it is not surprising thatmany of those same techniques are effective when weuse computers. Newton's method is a classicexample ofthis phenomenon. Another useful approach for evaluating mathematical functions is to use Taylorseries expansions (see Exercises 1.3.35-36).

Number conversion. Binary (Program 1.3.7) printsthe binary (base 2) representation of the decimal number typed as the command-line argument. It is based ondecomposing a number into a sum of powers of two.For example, the binary representation of 19 is 10011,which is the same as saying that 19 = 16 + 2 + 1. Tocompute the binary representation of N, we consider thepowers of 2 less than or equal to Nin decreasing orderto determine which belong in the binary decomposition (and therefore correspond to a 1 bit in the binaryrepresentation). The process corresponds precisely tousing a balance scale to weigh an object, using weightswhose values are powers of two. First, we find largestweight not heavier than the object. Then, consideringthe weights in decreasing order, we add each weight totest whether the object is lighter. If so, we remove the

greaterthan 16

1????

less than 16 + 8

less than 16 + 4

100??

63

greater than 16+ 2

1001?

equal to 16 + 2+1

10011

10000+10+1 = 10011

Scaleanalog to binaryconversion


Siligt^^

•*:?.

Wm

1mm%0

p

i

ii®|

18

Program 1.3.7 Convertingto binary

public class Binary

{public static void main(String[] args){ // Print binary representation of N.

int N = Integer.parselnt(args[0]);int v = 1;while (v <= N/2)

v = 2*v;// Now v is the largest power of 2 <= N.

int n = N;while (v > 0){ // Cast out powers of 2 in decreasing order.

if (n < v) { System.out.print(0);else { System.out.print(l); nv = v/2;

}System.out.pri ntln();

-= v;

integer to convert

currentpowerof2

current excess

Thisprogram prints thebinary representation of a positive integer given as thecommand-lineargument, bycasting outpowers of2 in decreasing order (seetext).

% Java Binary 1910011

% Java Binary 100000000101111101011110000100000000

Z&VST&Si !^^S^*3^'i^K;^^»5^S»^p^^^a^^^Q

weight; if not, we leavethe weight and try the next one. Eachweight corresponds toabit in the binary representationofthe weight ofthe object:leavingaweight corresponds to a 1bit in the binary representation of the object'sweight, and removing aweight corresponds to a 0 bit in the binary representation of the object's weight.

In Binary, the variablev corresponds to the current weight being tested, andthe variable n accounts for the excess (unknown) part of the object's weight (to


nbinary

representationV v > 0

binaryrepresentation

n < v output

19 10011 16 true 10000 false 1

3 0011 8 true 1000 true 0

3 Oil 4 true 100 true 0

3 01 2 true 10 false 1

1 1 1 true 1 false 1

0 0 false

Trace of'casting-out-powers-oftwo loop for Java Binary 19

simulate leaving a weight on the balance,we just subtract that weight from n). Thevalue of v decreases through the powers of two.When it is larger than n, Binaryprints 0; otherwise, it prints 1 and subtracts v from n.As usual, a trace (of the values of n, v, n < v, and the output bit for each loop iteration) can be very useful inhelping you to understand the program. Read from top to bottom in the rightmostcolumn of the trace, the output is 10011, the binary representation of 19.

Converting data from one representation to another is a frequent theme inwriting computer programs. Thinking about conversion emphasizes the distinction between an abstraction (an integer like the number of hours in a day) and arepresentation of that abstraction (24 or 11000). The irony here is that the computer's representation of an integer is actuallybased on its binary representation.

Simulation. Our next example is different in character from the ones we have been considering, butit is representative of a common situation where weuse computers to simulate what might happen inthe real world so that we can make informed deci

sions. The specific example that we consider now isfrom a thoroughly studied classof problems knownas gambler's ruin. Suppose that a gambler makes aseries of fair $1 bets, starting with some given initial stake. The gambler alwaysgoes broke eventually,but when we set other limits on the game, variousquestions arise. For example, suppose that the gam-

stake

goal

stake

Gambler simulationsequences

65


''^rtfrfr.afrartiiftSiird1

11

m

Program 13.8 Gambler's ruin simulation

public class Gambler{

public static void main(String[] args){ // Run T experiments that start with $stake

// and terminate on $0 or Sgoal.int stake = Integer.parselnt(args[0]);int goal = Integer.parselnt(args[1]);int T = Integer.parselnt(args[2]);int bets = 0;int wins = 0;for (int t = 0; t < T; t++){ // Run one experiment.

int cash = stake;while (cash > 0 && cash < goal){ // Simulate one bet.

bets++;if (Math.random() < 0.5) cash++;else cash—;

} // Cash is either 0 (ruin) or $goal (win)if (cash == goal) wins++;

}System.out.println(100*wins/T + "% wins");System.out.println("Avg # bets: " + bets/T);

}}

stake

goal

T

bets

wins

cash

initial stake

walkaway goal

number of trials

bet count

win count

cash on hand

The inner while loop in this program simulates a gambler with $stake who makes a seriesof%l bets, continuing untilgoingbroke orreaching Sgoal. The running timeof this programisproportional to T times the average number of bets. For example, the third command belowcauses nearly 100 million random numbers to begenerated.

% Java Gambler 10 20 100050% wins

Avg # bets: 100% Java Gambler 50 250 10019% wins

Avg # bets: 11050% Java Gambler 500 2500 10021% wins

Avg # bets: 998071

~,^^^^^^^~^^^^^^^^^^^^^^^^^^^^^^^^^^^^^s

^^^P^^W«l^lP^^^^^pf!PP^P

i


bier decides ahead of time to walk awayafter reachinga certain goal.What are thechances that the gambler willwin? How many bets might be needed to win or losethe game? What is the maximum amount of money that the gamblerwillhaveduring the course of the game?

Gambler (Program 1.3.8) is a simulation that can help answer these questions. It does a sequence of trials, using Math. random () to simulate the sequenceof bets, continuing until the gambler is broke or the goal is reached, and keepingtrack of the number ofwins and the number of bets. After running the experimentfor the specified number of trials, it averages and prints out the results. Youmightwish to run this program for various values of the command-line arguments, notnecessarilyjust to plan your next trip to the casino,but to help you think about thefollowing questions: Is the simulation an accurate reflection of what would happen in real life? How many trials are needed to get an accurate answer?What arethe computational limits on performing such a simulation?Simulations are widelyused in applications in economics, science,and engineering, and questions of thissort are important in any simulation.

In the case of Gambl er, we are verifyingclassical results from probability theory,which saythe probability ofsuccess is the ratio ofthe stake tothegoaland that theexpected number ofbets is theproduct ofthe stake and the desiredgain(the differencebetween the goal and the stake).For example, if you want to go to Monte Carlo totry to turn $500 into $2,500,you have a reasonable (20%) chance of success, butyou should expect to make a million $1 bets! If you try to turn $1 into $1,000,youhave a .1% chance and can expect to be done (ruin, most likely) in about 999 bets.

Simulation and analysis go hand-in-hand, eachvalidating the other. In practice, the value of simulation is that it can suggest answers to questions that mightbe too difficult to resolve with analysis. For example, suppose that our gambler,recognizing that there will never be enough time to make a million bets, decidesahead of time to set an upper limit on the number of bets. How much money canthe gambler expect to take home in that case? You can address this question withan easychangeto Program 1.3.8 (seeExercise 1.3.24), but addressingit with mathematical analysis is not so easy.


Factoring. Aprime is an integergreater than one whoseonly positive divisors areone and itself.The prime factorization of an integer is the multiset of primes whoseproduct is the integer. For example, 3757208 = 2*2*2*7*13*13*397. Factors(Program 1.3.9)computes the prime factorization of any given positive integer. Incontrast to many of the other programs that we have seen (which we could do in a

few minutes with a calculator or even a pencil and paper),this computation would not be feasible without a computer. How would you go about trying to find the factors ofa number like 287994837222311? You might find the factor 17 quickly, but evenwith a calculator it would take youquite a while to find 1739347.

Although Factors is compact and straightforward,it certainly will take some thought to for you to convinceyourselfthat it produces the desired result for any giveninteger.Asusual, followinga trace that shows the values of thevariablesat the beginning of each iteration of the outer forloop is a good wayto understand the computation. For thecase where the initial value of Nis 3757208, the inner whi 1eloop iterates three times when i is 2, to remove the threefactors of 2; then zero times when i is 3, 4, 5, and 6, sincenone of those numbers divide 469651; and so forth. Tracing the program for a few exampleinputs clearly reveals itsbasicoperation.To convince ourselves that the programwillbehaveas expectedfor all inputs, we reason about what weexpecteachof the loops to do. The whi 1e loop clearlyprintsand removes from n all factors of i, but the key to understanding the program is to see that the following fact holdsat the beginningof each iteration of the for loop: n has nofactorsbetween 2 and i -1. Thus, if i is not prime, it will notdivide n; if i is prime, the whi 1e loop will do its job. Once

we know that n has no factors less than or equal to i, we also know that it has nofactors greaterthan n/i, so weneedlookno further when i is greaterthan n/i.

In a more naive implementation, wemight simplyhave usedthe condition (i< n) to terminate the for loop.Even given the blindingspeedof modern computers, such a decision would have a dramatic effect on the size of the numbers that

wecouldfactor. Exercise 1.3.26 encourages youto experiment with the programto

2 3757208

3 469651

4 469651

5 469651

6 469651

7 469651

8 67093

9 67093

10 67093

11 67093

12 67093

13 67093

14 397

15 397

16 397

17 397

18 397

19 397

20 397

output

2 2 2

13 13

397

Trace ofJava Factors 3757208


^Ifll^^^^^S

nSs^

^VftSafcafeaata

Program 13.9 Factoring integers

public class Factors{

public static void main(String[] args){ // Print the prime factors of N.

long N = Long.parseLong(args[0]);long n = N;for (long i = 2; i <= n/i; i++){ // Test whether i is a factor.

while (n % i == 0){ // Cast out and print i factors,

n /= i;System.out.print(i + " ");

} // Any factors of n are greater than i.}if (n > 1) System.out.print(n);System.out.println();

Java Factors 37572082 2 2 7 13 13 397

learn the effectiveness of this simple change. On a computer that can do billionsof operations per second, we could factor numbers on the order of 109 in a fewseconds; with the (i <= n/i) test we can factor numbers on the order of 1018 in a

comparable amount of time. Loops give us the ability to solve difficult problems,but they also giveus the ability to construct simple programs that run slowly, so wemust alwaysbe cognizant of performance.

In modern applications in cryptography, there are important situations wherewe wish to factor truly huge numbers (with, say, hundreds or thousands of digits).Such a computation is prohibitively difficult even with the use of a computer.

integer tofactorunfactoredpart

potentialfactor


Other conditional and loop constructs To more fully cover the Java language, we consider here four more control-flow constructs. You need not thinkabout using these constructs for every program that you write, because you arelikelyto encounter them much less frequently than the i f, whi 1e, and for statements.You certainly do not need to worryabout using these constructsuntil youare comfortable using i f, whi 1e, and for. You might encounter one of them in aprogram in a book or on the web, but many programmers do not use them at alland we do not use any of them outside this section.

Break statement. In some situations, we want to immediately exit a loopwithoutletting it run to completion. Java provides the break statement for this purpose.For example, the following code is an effective wayto test whether a givenintegerN>1 is prime:

i nt i;for (i = 2; i <= N/i; i++)

if (N % i == 0) break;if (i > N/i) System.out.println(N + " is prime");

There are two different ways to leave this loop: either the break statement is executed (because i divides N, so Nis not prime) or the for loop condition is notsatisfied (because no i with i <= N/i wasfound that divides N, which implies thatNis prime). Note that we have to declare i outside the for loop instead of in theinitializationstatement so that its scopeextendsbeyond the loop.

Continue statement. Java also provides a way to skip to the next iteration of aloop: the continue statement. When a continue is executed within a loop body,the flow of control transfers directly to the increment statement for the next iteration of the loop.

Switch statement. The i f and i f-el se statements allow one or two alternativesin directing the flow of control. Sometimes, a computation naturally suggestsmorethan two mutually exclusive alternatives. We could use a sequence or a chain ofif-else statements, but the Java switch statement provides a direct solution. Letus move right to a typical example.Rather than printing an i nt variable day in aprogram that works with days of the weeks (such as a solution to Exercise 1.2.29),it is easier to use a swi tch statement, as follows:


swi tch

{case

case

case

case

case

case

(day)

case 6:

System.out.System.out.System.out.System.out.System.out.System.out,System.out.

}

("Sun")("Mon")due")("Wed")("Thu")("Fri")("Sat")

pri ntl nprintlnprintlnprintlnprintlnprintlnprintln

break;break;break;break;break;break;break;

When you have a program that seems to have a long and regular sequence of i fstatements, you might consider consulting the booksite and using a switch statement, or using an alternate approach described in Section 1.4.

Do-while loop. Anotherway to writea loop is to usethe template

do { <statements> } while Q<boolean expression^;

The meaning of this statement is the same as

while Q<boolean expression^ { <statements> }

exceptthat the first test of the condition is omitted. If the condition initiallyholds,there is no difference. For an example in which do-while is useful, consider theproblem of generating points that are randomly distributed in the unit disk. Wecan use Math. random() to generate x and y coordinates independently to get pointsthat are randomly distributed in the 2-by-2 square centered on the origin. Mostpoints fallwithin the unit disk, so we just reject those that do not. We always wantto generate at least one point, so a do-whi1e loop is ideal for this computation. Thefollowing code setsx and y such that the point (x, y) is randomly distributed in theunit disk:

do

{ // Scale x and y to be random inx = 2.0*Math.random() - 1.0;y = 2.0*Math.random() - 1.0;

} while (Math.sqrt(x*x + y*y) > 1.0);

(-1, 1).

Since the area of the disk is tt and the area of the square is 4, theexpected number of times the loop is iterated is 4/ir (about 1.27).

/(0,0)

71

(i,i)/


Infinite loops Before you write programs that use loops, you need to thinkabout the following issue: what if the loop-continuation condition in a whi 1e loopis always satisfied? With the statements that you havelearned so far,one of two badthings could happen, both of which you need to learn to cope with.

First, suppose that such a loop calls System. out. pri ntl n(). For example,ifthe condition in TenHellos were (i > 3) insteadof (i <= 10), it would alwaysbe true. What happens? Nowadays, weuse print as an abstraction to mean displayin a terminal window and the result of attempting to displayan unlimited numberof lines in a terminal window is dependent on operating-system conventions. If

your system is set up to have print mean print characters ona piece of paper> you might run out of paper or have to unplug the printer. In a terminal window,you need a stop printingoperation. Beforerunning programs with loops on your own,you make sure that you know what to do to "pull the plug" onan infinite loop of System. out. pri ntl n() calls and then testout the strategy by making the change to TenHel1os indicatedaboveand trying to stop it. On most systems,<ct rl -c> meansstop thecurrentprogram, and should do the job.

Second, nothing might happen. If your program has aninfinite loop that does not produce any output, it will spinthrough the loop and you will see no results at all. When youfind yourself in such a situation, you can inspect the loops tomake sure that the loop exit condition always happens, but theproblem may not be easy to identify. One way to locate sucha bug is to insert calls to System. out. pri ntl n() to producea trace. If these calls fall within an infinite loop, this strategyreduces the problem to the casediscussed in the previous paragraph, but the output might giveyou a clue about what to do.

You might not know (or it might not matter) whether a loop is infinite or justvery long. Even BadHel 1os eventually would terminate after printing over a billionlines because of overflow.If you invoke Program 1.3.8with arguments such as j avaGambler 100000 200000 100, you may not want to wait for the answer. Youwilllearn to be aware of and to estimate the running time of your programs.

Why not have Javadetect infinite loops and warn us about them? Youmightbe surprised to know that it is not possible to do so, in general. This counterintuitive fact is one of the fundamental results of theoretical computer science.

public class BadHellos

int i = 4;while (i > 3)

{System.out.pri ntln

(i + "th Hello");i = i +1;

}

% Java BadHellos1st Hello

2nd Hello

3rd Hello

5th Hello

6th Hello

7th Hello

An infinite loop


Summary For reference, the accompanying table lists the programs that wehave considered in this section. They are representativeof the kinds of tasks we canaddress with short programs comprised of i f, whi 1e, and for statements processing built-in types of data. These types ofcomputations are an appropriate way tobecome familiar with the basic Java flow-

of-control constructs. The time that youspend now working with as many suchprograms as you can will certainly payoff for you in the future.

To learn how to use condition

als and loops, you must practice writing and debugging programs with if,while, and for statements. The exer

cises at the end of this section providemany opportunities for you to begin thisprocess. For each exercise,you will writea Java program, then run and test it. Allprogrammers know that it is unusual tohave a program work as planned the firsttime it is run, so you will want to have an understanding of your program and anexpectation of what it should do, step by step.At first, use explicit traces to checkyour understanding and expectation.Asyou gain experience, you will find yourselfthinking in terms of what a trace might produce as you compose your loops. Askyourself the following kinds of questions: What will be the values of the variablesafter the loop iterates the first time?The second time? The final time? Is there anyway this program could get stuck in an infinite loop?

Loops and conditionals are a giant step in our ability to compute: i f, whi1e,and for statements take us from simple straight-line programs to arbitrarily complicated flow of control. In the next several chapters, wewill take more giant stepsthat will allow us to process large amounts of input data and allow us to defineand process types of data other than simple numeric types. The if, while, andfor statements of this section will play an essential role in the programs that weconsider as we take these steps.

program description

Flip simulate a coin flip

TenHellos your first loop

PowersOfTwo compute and print a table of values

DivisorPattern your first nested loop

Harmonic compute finite sum

Sqrt classiciterative algorithm

Binary basic number conversion

Gambler simulation with nested loops

Factors whi 1e loop within a for loop

Summary ofprograms in thissection


Q. What is the difference between = and ==?

A, We repeat this question here to remind you to be sure not to use = when youmean == in a conditional expression. The expression (x = y) assigns the value ofy to x, whereas the expression (x == y) tests whether the two variables currentlyhave the same values. In some programming languages, this difference can wreakhavoc in a program and be difficult to detect, but Java's type safety usually willcome to the rescue. For example, if we make the mistake of typing (t = goal)instead of (t == goal) in Program 1.3.8,the compiler finds the bug for us:

javac Gambler.javaGambler.Java:18: incompatible typesfound : int

required: booleanif (t = goal) wins++;

A

1 error

Becareful about writing i f (x = y) when x and y are bool ean variables, since thiswill be treated as an assignment statement, which assigns the value of y to x andevaluates to the truth value of y. For example, instead of writing if (i sPri me =false), you should write if (HsPrime).

Q. So I need to pay attention to using ==instead of=when writing loops and conditionals. Is there something else in particular that I should watch out for?

A. Another common mistake is to forget the braces in a loop or conditional with amulti-statement body. For example, consider this version of the code in Gambl er:

for (int t = 0; t < T; t++)for (cash = stake; cash > 0 && cash < goal; bets++)

if (Math.random() < 0.5) cash++;else cash--;

if (cash == goal) wins++;

The code appears correct, but it is dysfunctional because the second i f is outsideboth for loops and gets executed just once. Our practice of using explicit braces forlong statements is precisely to avoid such insidious bugs.

13 Conditionals and Loops

Q. Anything else?

A. The third classic pitfall is ambiguity in nested i f statements:

if <exprl> if <expr2> <stmntA> else <stmntB>

In Java this is equivalent to

if <exprl> {if <expr2> <stmntA> else <stmntB> }

even if you might have been thinking

if <exprl> {if <expr2> <stmntA> } else <stmntB>

Again,using explicit braces is a good way to avoidthis pitfall.

Q. Are there cases where I must use a for loopbut not awhi 1e, or viceversa?

A. No. Generally, you should use a for loop when you have an initialization, anincrement, and a loop continuation test (if you do not need the loop control variable outside the loop). But the equivalent whi 1e loop stillmight be fine.

Q. What are the rules on where we declare the loop-control variables?

A. Opinions differ. In older programming languages, it was required that all variables be declared at the beginningof a <body>, so many programmers are in thishabit and there is a lot of code out there that follows this convention. But it makes a

lot of sense to declare variables where they are first used,particularly in for loops,when it is normallythe case that the variable is not neededoutsidethe loop. However, it is not uncommon to need to test (and therefore declare) the loop-controlvariable outside the loop, as in the primality-testing codewe considered as an example of the break statement.

Q. What is the difference between ++i and i ++?

A. As statements, there is no difference. In expressions, both increment i, but ++ihas the value after the increment and i++ the value before the increment. In this

book, we avoid statements like x = ++i that have the side effectof changing variablevalues. So, it is safe to not worry much about this distinction and just use i++

75


in for loops and as a statement. When we do use ++i in this book, we will call attention to it and saywhy we areusing it.

Q. So,<initia 7ize> and <increment>canbe any statements whatsoeverin a forloop. How can I take advantage of that?

A. Some experts take advantage of this ability to create compact code fragments,but, as a beginner, it is best for you to use a whi1e loop in such situations. In fact,the situation is even more complicated because <initialize> and <increment>canbe sequences of statements, separated by commas. This notation allows for codethat initializes and modifies other variablesbesides the loop index. In some cases,this ability leads to compact code. For example, the following two lines of codecould replace the last eight lines in the body of the main() method in PowersOfTwo(Program 1.3.3):

for (int i = 0, v = 1; i <= n; i++, v *= 2)System, out. pri ntl n(i + " " + v);

Such code is rarelynecessaryand better avoided, particularlyby beginners.

Q Can I use a doubl e value as an index in a for loop?

A It is legal, but generally bad practice to do so. Consider the following loop:

for (double x = 0.0; x <= 1.0; x += 0.1)System.out.println(x + " " + Math.sin(x));

How many times does it iterate? The number of iterations depends on an equalitytest between doubl e values,which may not always give the result that you expect.

Q. Anything elsetricky about loops?int v = 1;

A. Not all parts of a for loop need to be filled whi]e^2T N/2)in with code. The initialization statement, the

null incrementstatement

*

boolean expression, the increment statement, for ^"^Y =l; v <- N/2; )and the loop body can eachbe omitted. It is generallybetter style to use a while statement than for (int v = 1; v <= N/2; v *= 2)null statements ina for loop. In the code inthis ; * """loop bodybook, we avoid null statements. Three equivalent loops


1.3.1 Write a program that takes three integer command-line arguments andprints equal if all three are equal, and not equal otherwise.

1.3.2 Write a more general and more robust version of Quadratic (Program1.2.3) that prints the roots of the polynomial ax2 + bx + c, prints an appropriatemessage if the discriminant is negative, and behavesappropriately (avoiding division by zero) if a is zero.

1.3.3 What (if anything) is wrong with each of the following statements?a. if (a > b) then c = 0;

b. if a > b { c = 0; }

c. if (a > b) c = 0;

d. if (a > b) c = 0 else b = 0;

1.3.4 Write a code fragment that prints true if the doubl e variables x and y areboth strictly between 0 and 1 and f al se otherwise.

1.3.5 Improveyour solution to Exercise 1.2.25 by addingcode to checkthat thevalues of the command-line arguments fall withinthe ranges of validity of the formula, and also adding code to print out an error message if that is not the case.

1.3.6 Supposethat i and j are both of type i nt. What is the valueof j after eachof the followingstatements is executed?

a. for (i = 0, j = 0; i < 10; i++)

b. for (i = 0, j = 1; i < 10; i++)

c. for (j = 0; j < 10; j++) j += j;

d. for (i = 0, j = 0; i < 10; i++)

3 += i;

j += j;

j += j++;

1.3.7 Rewrite TenHel 1os to make a program Hel 1os that takes the number oflines to print as a command-line argument. You mayassume that the argument isless than 1000. Hint: Use i %10 and i %100 to determine when to use st, nd, rd, orth for printing the i th Hel1o.

1.3.8 Write a program that, usingone for loop and one i f statement, prints the

77


integers from 1,000to 2,000with five integers per line. Hint: Use the %operation.

1.3.9 Write a program that takes an integer N as a command-line argument,uses Math. random() to print Nuniform random values between 0 and 1, and thenprints their averagevalue (see Exercise 1.2.30).

1.3.10 Describewhat happens when you try to print a ruler function (seethe tableon page 57) with a value of Nthat is too large, such as 100.

1.3.11 Write a program FunctionGrowth that prints a table of the values logJV,JV, JV logJV, JV2, JV3, and 2N for JV = 16,32,64,..., 2048. Usetabs (\t characters) toline up columns.

1.3.12 What are the values of mand n after executing the following code?

int n = 123456789;int m = 0;while (n != 0)

{m = (10 * m) + (n % 10);n = n / 10;

}

1.3.13 What does the following program print ?

int f = 0, g = 1;for (int i = 0; i <= 15; i++){

System.out.p ri ntln(f);f = f + g;g = f - g;

}

Solution. Even an expert programmer will tell you that the only way to understand a program likethis is to trace it.When you do,you will find that it prints thevalues 0,1,1,2,3,5,8,13,21,34,55,89,134,233,377, and 610. These numbers arethe first sixteen of the famous Fibonacci sequence, which are defined by the following formulas: F0 = 0, Fx = 1,and Fn = FnA + Fn_2 for ft > 1.The Fibonacci sequencearises in a surprising variety of contexts, they have been studied for centuries, and


many of their properties are well-known. For example, the ratio of successive numbers approaches the golden ratio <|> (about 1.618) as n approaches infinity.

1.3.14 Write a program that takes a command-line argument JV and prints all thepositivepowers of two lessthan or equal to JV. Makesure that your program worksproperly for allvaluesof JV. (Integer. parselnt () willgeneratean error if JVis toolarge,and your program should print nothing if JV is negative.)

1.3.15 Expand your solution to Exercise 1.2.24 to print a table giving the totalamount paid and the remaining principal aftereachmonthly payment.

1.3.16 Unlike the harmonic numbers, the sum l/l2 + 1/22 + ... + 1/JV2 does converge to a constant as JV grows to infinity. (Indeed, the constant is tt2/6, so thisformula can be usedto estimate the value of it.) Which of the following for loopscomputes this sum? Assume that Nis an int initialized to 1000000 and sum is adoubl e initialized to 0.0.

<= N; i++) sum += 1 / (i*i);

<= N; i++) sum += 1.0 / i*i;

<= N; i++) sum += 1.0 / (i*i);

<= N; i++) sum += 1 / (1.0*i*i);

1.3.17 Show that Program 1.3.6 implements Newton's method for finding thesquareroot of c. Hint: Use the factthat the slope of the tangent to a (differentiable)function f(x) atx = t isf'(t) to find the equation of the tangent line and then usethat equationto find the point where the tangentline intersects the x-axis to showthat youcanuseNewton's methodto find a rootofanyfunction asfollows: at eachiteration, replace the estimate t by t - fit) /f'(t).

1.3.18 Using Newton's method, develop a program that takes integers Nand k ascommand-line arguments and prints the kth root of N(Hint: see Exercise 1.3.17).

1.3.19 Modify Binary to get a program Karythat takes i and k as command-lineargumentsand converts i to base k. Assume that i is an integerin Java's long datatype and that k is an integerbetween 2 and 16. For bases greater than 10,use theletters Athrough Fto represent the 11ththrough 16thdigits, respectively.

a. for (int i = 1; i

b. for (int i = 1; i

c. for (int i = 1; i

d. for (int i = 1; i


1.3.20 Write a code fragment that puts the binary representation of a positiveinteger Ninto a Stri ng s.

Solution. Java has a built-in method Integer. toBi narySt ri ng(N) for this job,but the point of the exercise is to seehow such a method might be implemented.Workingfrom Program 1.3.7, we get the solution

String s = "";int v = 1;while (v <= n/2) v = 2*v;while (v > 0)

{if (n < v) { s += 0; }else { s += 1; n -= v; }v = v/2;

}

A simpleroption is to work from right to left:

String s = "";for (int n = N; n > 0; n /= 2)

s = (n % 2) + s;

Both of these methods are worthy of careful study.

1.3.21 Write a version of Gambl er that uses two nested whi1e loops or two nestedfor loops insteadof a whi 1e loop inside a for loop.

1.3.22 Write a program GamblerPlot that traces a gambler's ruin simulation byprinting a line after each betinwhich one asterisk corresponds to each dollar heldby the gambler.

1.3.23 Modify Gambler to take an extra command-line argument that specifiesthe (fixed) probabilitythat the gamblerwins eachbet. Useyour program to try tolearnhowthis probability affects the chance of winning and the expected numberof bets.Trya valueofp close to .5 (say, .48).

1.3.24 Modify Gambler to take an extra command-line argument that specifiesthe number of bets the gambler iswilling to make, so that there are three possible


ways for the game to end: the gambler wins, loses, or runs out of time. Add to theoutput to givethe expected amount of money the gamblerwillhavewhen the gameends. Extra credit: Use your program to plan your next trip to Monte Carlo.

1.3.25 Modify Factors to print just one copy each of the prime divisors.

1.3.26 Run quick experiments to determine the impact of using the terminationcondition (i <= N/i) instead of (i < N) in Factors in Program 1.3.9. For eachmethod, find the largest n such that when you type in an n digit number, the program is sure to finish within 10 seconds.

1.3.27 Writea program Checkerboard that takes one command-lineargument Nand usesa loop within a loop to print out a two-dimensional N-by-N checkerboardpattern with alternating spaces and asterisks.

1.3.28 Write a program GCD that finds the greatest commondivisor (gcd) of twointegers using Euclid's algorithm, which is an iterative computation based on thefollowing observation: if x isgreater than y,then if y divides x,the gcdof x and y isy; otherwise,the gcd of x and y is the same as the gcdof x % y and y.

1.3.29 Write a program RelativelyPrime that takes one command-line argument Nand prints out an N-by-N table such that there is an * in row i and column jif the gcdof i and j is 1 (i and j are relatively prime) and a space in that positionotherwise.

1.3.30 Writea program Powe rsOfKthat takes an integer kascommand-lineargument and prints all the positive powers of k in the Java long data type.Note: Theconstant Long.MAX_VALUE is the value of the largest integer in 1ong.

1.3.31 Generate a random point (x, y, z) on the surface of a sphere using Mar-saglia's method: Pick a random point (a, b) in the unit disk using the method de-scribed at theendof this section. Then, set x = 2 a Jl -a2 - b2 .y = 2 bJl -a2 - b2.andz= l-2(a2 + fr2).

81


X^reatm^S^eXSes..

1.3.32 Ramanujan's taxi. Srinivasa Ramanujan was an Indian mathematicianwho became famous for his intuition for numbers. When the English mathematician G. H. Hardy came to visit him one day, Hardy remarked that the number ofhis taxi was 1729,a rather dull number. Towhich Ramanujan replied, "No, Hardy!No, Hardy! It is a very interestingnumber. It is the smallestnumber expressible asthe sum of two cubes in two different ways." Verify this claim by writing a programthat takesa command-line argument Nand prints out all integerslessthan or equalto Nthat can be expressed as the sum of two cubes in two differentways. In otherwords, finddistinctpositive integers a, b, c, and dsuchthat a3 + b3 = c3 + d3. Usefournested for loops.

1.3.33 Checksum. The International Standard Book Number (ISBN) is a 10-digitcode that uniquely specifies a book. The rightmost digit is a checksum digit thatcan be uniquely determined from the other 9 digits, from the conditionthat dx +2d2 +3d3 +... + 10d10 mustbeamultiple of 11 (here d{ denotes the ithdigit from theright).Thechecksum digitd{ canbe anyvalue from0to 10. TheISBN convention isto use the character 'X1 to denote 10.Example: the checksum digit correspondingto 020131452 is 5 since 5 is the onlyvalueof x between 0 and 10 for which

10-0 + 9-2 + 8-0 + 7-1 + 6-3 + 5-1 +44 +3-5 + 2-2 + 1-x

is a multiple of 11. Write a programthat takes a 9-digitintegeras a command-lineargument, computes the checksum, and prints out the the ISBN number.

1.3.34 Countingprimes. Write a program PrimeCounter that takes a command-line argument Nand finds the number of primes less than or equal to N. Use it toprint out the numberof primesless than or equalto 10million. Note: ifyouarenotcareful, your program maynot finish in a reasonable amount of time!

1.3.35 2D random walk. A two-dimensional random walk simulates the behavior

of a particle moving in a grid of points. At each step, the random walker movesnorth, south, east, or westwith probabilityequal to 1/4, independent of previousmoves. Writea program RandomWal ker that takesa command-line argument Nandestimates how long it will take a random walker to hit the boundary of a 2N-by-2Nsquare centered at the starting point.


1.3.36 Exponential function. Assume that x is a positive variable of type doubl e.Write a code fragment that uses the Taylor series expansion to set the value of sumto ex = 1+ x + x2/2\ + x3/3! +... .

Solution. The purpose of this exercise is to get youto think about how alibraryfunction likeMath. exp() mightbeimplemented interms of elementary operators.Try solving it, then compare yoursolution with the one developed here.

We startby considering the problem of computingone term. Suppose that xandterm are variables of typedoubl e andnisavariable of type i nt. The followingcode fragment sets term to xN/N\ using the direct methodof having oneloop forthe numerator andanother loop for the denominator, then dividing the results:

double num = 1.0, dem = 1.0;for (int i = 1; i <= n; i++) num *= x;for (int i = 1; i <= n; i++) den *= i;double term = num/den;

A better approach is to use just a single for loop:

double term =1.0;for (i = 1; i <= n; i++) term *= x/i;

Besides being more compact and elegant, the latter solution is preferable becauseit avoids inaccuracies caused by computing with huge numbers. For example, thetwo-loop approach breaks down for values like x = 10 and N = 100because 100! istoo large to represent as a doubl e.

To compute e*, we nest this for loop within another for loop:

double term = 1.0;double sum =0.0;for (int n = 1; sum != sum + term; n++){

sum += term;

term = 1.0;for (int i = 1; i <= n; i++) term *= x/i;

}

The number of times the loop iterates depends on the relative values of the nextterm and the accumulated sum. Once the value of the sum stops changing, we


leave the loop. (This strategy is more efficient than using the termination condition (term > 0) because it avoids a significant number of iterations that do notchange thevalue of the sum.) This code iseffective, but it is inefficient because theinner for loop recomputes allthe values it computedon the previous iterationofthe outer for loop. Instead, wecan makeuse of the term that wasadded in on theprevious loop iterationand solve the problemwith a single for loop:

double term = 1.0;double sum =0.0;for (int n = 1; sum != sum + term; n++)

{sum += term;

term *= x/n;

}

1.3.37 Trigonometric functions. Write two programs, Sin and Cos, thatcompute the sine and cosine functions using their Taylor series expansionssin x = x - x3/3! + x5/5\ - ... and cos x = 1 - x2/2\ + x4/4! - ... .

1.3.38 Experimental analysis. Runexperiments to determine the relative costs ofMath.expO and the methods from Exercise 1.3.36 for computing ex: the directmethod with nested for loops, the improvement with a single for loop, and thelatter with the termination condition (term > 0). Use trial-and-error with a command-line argument to determine how many times your computer can performeach computation in 10 seconds.

1.3.39 Pepys problem. In 1693 Samuel Pepys asked Isaac Newtonwhich is morelikely: getting 1 at least oncewhen rolling a fair die six times or getting 1 at leasttwice when rolling it 12times. Write a program that could have providedNewtonwith a quick answer.

1.3.40 Game simulation. In the 1970s game show Let's Make a Deal,a contestantispresented withthreedoors. Behind oneof themisavaluable prize. After the contestant choosesa door, the host opens one of the other two doors (never revealingthe prize, of course).The contestant is then giventhe opportunity to switch to theother unopened door. Should the contestant do so? Intuitively, it might seem that


the contestant's initial choice door and the other unopened door are equally likelytocontain the prize, so there would beno incentive toswitch. Write aprogram Mon-teHal1 to testthis intuitionbysimulation. Your program should takea command-line argument N, play the game Ntimes using each ofthe two strategies (switch ordo notswitch), and print the chance ofsuccess for each ofthe two strategies.

1.3.41 Median-of-5. Write a program that takes five distinct integers from thecommand line and prints the median value (the value such that two of the othersare smaller and two are larger). Extra credit: Solve the problem with aprogram thatcompares values fewer than seven times forany given input.

1.3.42 Sorting three numbers. Suppose that the variables a, b, c, and t are all ofthesame numeric primitive type. Prove thatthe following code puts a, b, andc inascending order:

if (a > b) { t = a; a = b; b = t; }if (a > c) { t = a; a = c; c = t; }if (b > c) { t = b; b = c; c = t; }

1.3.43 Chaos. Write a program to study the following simple model for populationgrowth, which mightbeapplied to study fish in a pond,bacteria in a testtube,or any ofa host of similar situations. We suppose thatthepopulation ranges from0 (extinct) to 1 (maximum population thatcan besustained). If thepopulation attime t is x, then wesuppose the population at time t + 1 to be rx{\—x), where theargument r, known as thefecundity parameter, controls the rate of growth. Startwith asmall population—say, x=0.01—and study the result ofiterating themodel,for various values of r.For which values of r does thepopulation stabilize at x = 1- 1/r ?Can you sayanythingabout the populationwhen r is 3.5? 3.8? 5?

1.3.44 Euler's sum-of-powers conjecture. In 1769 Leonhard Euler formulated ageneralized version ofFermat's Last Theorem, conjecturing thatat least nnth powersareneeded to obtaina sumthat isitselfannth power, forn> 2.Write a programto disprove Euler's conjecture (which stood until 1967), using a quintuply nestedloop to find four positive integers whose 5thpower sums to the 5th power of another positive integer.That is, find a, b,c,d,and e such that a5 + b5 + c5+ d5= e5.Use the 1ong data type.

85


1.4 Arrays

In this section,weconsidera fundamental programmingconstruct known as thearray. The primary purpose of an array is to facilitate storing and manipulatinglarge quantities ofdata. Arrays play anessential role in many data processing tasks.They also correspond tovectors andmatrices, which are widely used inscience andin scientific programming. We will con-sider basic properties of array processingin Java, with many examples illustratingwhythey are useful.

An arraystoresa sequence of valuesthat are all of the same type. Processingsuch a set of values is very common. Wemight have exam scores, stock prices, nucleotides ina DNA strand, or characters ina book. Each of these examples involve a large numberof values that are allof thesame type.

We want not only to storevalues but also directly access eachindividual value. The method that we use to refer to individual values in

an arrayis numbering and then indexing them. If wehave N values, wethink of them as beingnumberedfrom 0 to N-1. Then,we can unambiguously specify oneof thembyreferring to the zth value foranyvalueof i from 0 to N— 1. To refer to the ith value in an array a, we use thenotation a[i], pronounced a sub i. This Java construct is known as aone-dimensional array.

The one-dimensional array is our first example in this book of adata structure (a method for organizing data).We also considerin thissectiona more complicated data structureknown as a two-dimensionalarray. Datastructuresplayan essential role in modern programming—Chapter 4 is largelydevoted to the topic.

Typically, when we have a large amountof data to process, we first put allofthe data into one or more arrays. Then weusearray indexing to referto individualvalues and to process the data. We consider suchapplications whenwediscuss datainput in Section 1.5 and in the case study that is the subject of Section 1.6. In thissection, we expose the basic properties of arrays by considering examples whereour programs first populate arrays withcomputed values fromexperimental studies and then process them.

1.4.1

1.4.2

1.4.3

1.4.4

Samplingwithout replacement. . . 94Coupon collector simulation. ... 98Sieve of Eratosthenes 100

Self-avoiding random walks .... 109

Programs in thissection

a[0]

a[l]

a[2]

a[3]

a[4]

a[5]

a[6]

a[7]

An array

1.4 Arrays g7

Arrays in Java Making anarray ina Java program involves three distinct steps:• Declare the array name and type.• Create the array.• Initialize the array values.

To declare thearray, youneed to specify a name andthetype ofdatait will contain.To create it, you need to specify its size (thenumber of values). For example, thefollowing code makes an array of Nnumbers of type doubl e, allinitialized to 0.0:

doubled a;a = new double[N];for (int i = 0; i < N; i++)

a[i] = 0.0;

Thefirst statement is the arraydeclaration. It is just like a declaration of a variableof the corresponding primitive type except for the square brackets following thetypename, which specify that wearedeclaring an array. Thesecond statementcreates the array. This action is unnecessary for variables of a primitive type (so wehave not seen a similar action before), but it isneeded forallothertypes of datainJava (see Section 3.1). In thecode in thisbook, we normally keep thearraylengthinan integervariable N, but any integer-valued expression willdo. The for statementinitializes the Narrayvalues. We refer to each value byputtingits indexin bracketsafterthe arrayname. Thiscodesets allof the array entries to the value 0.0.

When youbegin to write code that uses an array, youmust be sure that yourcode declares, creates, and initializes it. Omitting one of these steps is a commonprogrammingmistake. For economy in code, weoftentakeadvantage of Java's default array initialization convention andcombine all three steps intoa single statement. For example, the following statement is equivalent to the code above:

doubled a = new double[N];

The code to the left of the equal sign constitutes the declaration; the code to theright constitutes the creation. Thefor loopisunnecessary in this case because thedefault initial value of variables of type doubl e in a Java array is0.0, but it wouldbe required if a nonzero value were desired. The default initial value is zero for allnumbers and fal se for type bool ean.ForSt ri ng andothernon-primitive types,the default is the value null, whichyou willlearn about in Chapter 3.

After declaring and creating an array, you can refer to any individual valueanywhere youwouldusea variable namein a programbyenclosing an integerin-


dexin braces afterthe arrayname. We refer to the i th itemwith the codea[i ]. Theexplicit initialization code shown earlier isan example of such a use. The obviousadvantage of using arrays is to avoid explicitly naming each variable individually.Using anarray index isvirtually thesame as appending theindex tothearray name:for example, if we wanted to process eight variables of type doubl e, we could declare each of them individuallywith the declaration

double aO, al, a2, a3, a4, a5, a6, a7;

and then refer to them as aO, al and so forth instead of declaring them with doubl e[] a = new double[8] and referring to them as a[0], a[1], and so forth. Butnaming dozens ofindividual variables in thisway would becumbersome andnaming millionsis untenable.

Asan example of codethat uses arrays, considerusingarrays to representvectors. We consider vectors in detail in Section 3.3; for the moment, think of a vectorasa sequence of real numbers. The dotproduct of two vectors (ofthe same length)is the sum of the products of their corresponding components. The dot productof twovectors that are represented asone-dimensional arrays x[] and y[] that areeach of length 3 is the expression x[0]*y[0] + x[l]*y[l] + x[2]*y[2]. If werepresent the two vectors asone-dimensional arrays x[] and y[] that areeach oflength Nand of type double, the dot product iseasy to compute:

0

double sum = 0.0; 0 30 50 15 15for (int i = 0; i < N; i++)

sum += x[i]*y[i];

i x[i] y[i] x[i]*y[i] sum

1 .60 .10 .06 .21

2 .10 .40 .04 .25

The simplicity of coding such computations .25makes the use ofarrays the natural choice for all Trace 0fdot product computationkinds of applications. (Notethat whenweusethenotation x[], we are referring to the whole array,asopposed to x[i ], whichisa reference to the i thentry.)

Theaccompanying tablehasmanyexamples of array-processing code, and wewill consider evenmore examples later in the book, because arrays play a centralrole in processing data in manyapplications. Before considering more sophisticated examples, we describe a number of important characteristics of programmingwith arrays.

1.4 Arrays

create an array

with random values

doubl e[] a = new doubl e[N];for (int i = 0; i < N; i++)

a[i] = Math.randomO;

print the array values,oneper line

for (int i = 0; i < N; i++)System.out.pri ntln(a[i]);

find themaximum ofthearray values

double max = Double.NEGATIVE_INFINITY;for (int i = 0; i < N; i++)

if (a[i] > max) max = a[i];

compute theaverage ofthearray values

double sum =0.0;for (int i = 0; i < N; i++)

sum += a[i];double average = sum / N;

copy toanother arraydoubl e[] b = new doubl e[N];for (int i = 0; i < N; i++)

b[i] = a[i];

reverse the elementswithinan array

for (int i =0; i < N/2; i++){

double temp = b[i];b[i] = b[N-l-i];b[N-i-l] = temp;

}

Typical array-processing code (for arrays ofN double values)

Zero-based indexing. We always refer to thefirst element ofan array asa[0], thesecondas a [1], and so forth. It mightseemmorenatural to you to referto the firstelement as a[l], the second value as a[2], and so forth, but starting the indexing with 0 has some advantages and has emerged as the convention used in mostmodern programming languages. Misunderstanding thisconvention oftenleads tooff-by one-errors that arenotoriously difficult to avoid and debug, sobe careful!

Array length. Oncewecreate an array, its size is fixed. Thereason that weneedtoexplicitly createarraysat runtime is that the Java compilercannot know how muchspace to reserve for the array at compile time (as it can for primitive-type values).Our convention is to keep the size of the array in a variable Nwhose value can beset at runtime (usually it is the value of a command-line argument). Java's standard mechanism is to allow a program to refer to the length of an array a[] withthe code a.length; we normally use Nto create the array, or set the value of Ntoa, 1ength. Note that the last element of an array is always a [a. 1ength-1].

89


Memory representation. Arrays are fundamental data structures in that theyhave a direct correspondence with memory systems on virtually all computers.The elements of an array are stored consecutively in memory, so that it is easyto quickly access any array value. Indeed, we can view memory itself as a giant

array. On modern computers, memory is implemented in hardware asa sequence of indexed memory locations that each can be quickly accessedwith an appropriate index.When referring to computer memory,wenormally refer to a location's indexas its address. It is convenient tothink of the name of the array—say, a—asstoring the memory addressof the first elementof the array a[0]. For the purposes of illustration,

jS suppose that the computer's memoryis organized as 1,000 values, withaddresses from 000 to 999. (This simplifiedmodel ignores the fact thatarrayelements canoccupy differing amountsof memorydepending ontheir type,but youcan ignore suchdetails for the moment.) Now, suppose that an arrayof eightelements is stored in memory locations 523through 530. In sucha situation, Java would store the memory address(index) of the first array value somewhere else in memory, along withthe arraylength. We refer to the address as a pointer and think of it aspointing to the referenced memory location. Whenwespecify a[i ], thecompiler generates code that accesses the desired value by adding theindex i to the memory address of the array a[]. For example, the Javacode a [4] would generatemachine code that finds the value at memorylocation 523 + 4 = 527. Accessing element i of an array is an efficientoperation because it simply requires adding two integers andthen referencing memory—just two elementary operations. Extending the modelto handle different-sized array elements just involves multiplying theindexby the elementsize before addingto the array address.

000 l;

vt

£ , , -'

123 523

124 8

} a.length

523 %\ a[0]

524 a[l]

525 r; a[2]

526 ^ a[3]

527 a[4]

528 .-; a[5]

529 a[6]

530 \ a [7]

;

999 ,

Memoryrepresentation

Memory allocation. When youusenew to create an array, Java reservesspace in memory for it. This process is called memory allocation. Thesame process is required for all variables that you use in a program. Wecallattention to it now because it isyour responsibilityto use new to al

locate memoryfor an arraybefore accessing anyof itselements. Ifyou fail to adhereto this rule, you willget a compile-timeuninitialized variable error. Java automatically initializes allof the values in an arraywhenit iscreated. You shouldrememberthat the time required to createan array is proportional to its length.

1A Arrays 91

Bounds checking. As already indicated, you must be careful when programmingwith arrays. It is your responsibility to use legal indices when accessing an arrayelement. If you have created an arrayof size Nand usean indexwhose value is lessthan 0 or greater than N-l, your program will terminate with an Arraylndex-OutOfBounds run-time exception. (In manyprogramming languages, such bujferoverflow conditions are not checked by the system. Such unchecked errors can anddo lead to debugging nightmares, but it is also not uncommon for such an error togo unnoticed and remain in a finished program. You mightbe surprised to knowthat such a mistake canbe exploited bya hacker to take control of a system, evenyour personal computer, to spread viruses, steal personal information, or wreakothermalicious havoc.) The errormessages provided byJava may seem annoyingto youat first, but theyaresmall price to payto have a moresecure program.

Setting array values at compile time. Whenwe have a small number of literalvalues that wewant to keep in array, we can declare and initialize it by listing thevalues between curlybraces, separated bycommas. Forexample, wemight usethefollowing codein a programthat processes playing cards.

String[] suit = { "Clubs", "Diamonds", "Hearts", "Spades" };

String[] rank ={

"2", "3", "4", "5", "6", "7", "8", "9", "10","Jack", "Queen", "King", "Ace"

};

After creatingthe two arrays, we can use them to print out a random card name,such as Queen of Clubs, as follows:

int i = (int) (Math.random() * rank.length);int j = (int) (Math.randomO * suit.length);System.out.println(rank[i] + " of " + suit[j]);

Thiscodeuses the idiomintroduced in Section 1.2 to generate randomindices andthen uses the indices to pick strings out of the arrays. Whenever the values of allarrayentriesare known at compile time (and the size of the array is not too large)it makes sense to usethis method of initializing the array—just put all the values inbraces on the right hand sideof an assignment in the arraydeclaration. Doingsoimplies array creation, so the new keyword is not needed.


Setting array values at runtime. A more typical situation is when we wish tocompute the values to be stored in an array. In this case, we can use array nameswith indices in the samewaywe usevariable names on the left sideof assignmentstatements. For example, we mightusethe following code to initialize an array ofsize 52 thatrepresents adeck of playing cards, using the two arrays justdefined:

String[] deck = new String[suit.length * rank.length];for (int i = 0; i < suit.length; i++)

for (int j = 0; j < rank.length; j++)deck[rank.length*i + j] = rank[i] + " of " + suit[j];

After this code has been executed, if you were to print out the contents of deck inorderfromdeck [0] throughdeck [51] usingSyst em. out.printlnO, you wouldget the sequence

2 of Clubs

2 of Diamonds

2 of Hearts

2 of Spades3 of Clubs

3 of Diamonds

Ace of Hearts

Ace of Spades

Exchange. Frequently, wewishto exchange two values in anarray. Continuingourexample with playing cards, the following code exchanges the cards at position iand j usingthe same idiom thatwetraced asour first example of the useofassignment statements in Section 1.2:

String t = deck[i];deck[i] = deck[j];deck[j] = t;

When we use this code, we areassured that we are perhaps changing the order ofthe values in the array but not the setofvalues in the array. When i and j are equal,the array is unchanged. When i and j are not equal,the values a[i ] and a[j] arefound in different places in the array. For example,if we wereto use this code withi equal to 1 and j equal to 4 in the deck array of the previous example, it wouldleave 3 of Clubs in deck[1] and 2 of Diamonds in deck[4].

1.4 Arrays

Shuffle. The following codeshuffles our deckof cards:

int N = deck.length;for (int i = 0; i < N; i++)

{int r = i + (int) (Math.random() * (N-i));String t = deck[i] ;deck[i] = deck[r];deck[r] = t;

}

Proceeding from left to right, we pick a random card from deck[i] throughdeck[N-l] (each card equally likely) and exchange it with deck[i]. This code ismore sophisticated than it might seem: First, we ensure that the cards in the deckafter the shuffle are the same as the cards in the deck before the shuffle by usingthe exchange idiom. Second, we ensure that the shuffleis randomby choosinguniformly from the cards not yet chosen.

Sampling without replacement. In many situations, we want to draw a randomsample from a set such that each member of the set appears at most once in thesample. Drawing numbered ping-pong balls from a basket for a lottery is an example of this kind of sample, as is dealing a hand from a deck of cards. Sampl e(Program 1.4.1) illustrates how to sample, using the basic operation underlyingshuffling. It takes command-line argumentsMand Nand creates a permutation ofsize N(a rearrangement of the integers from 0 to N-l) whose first Mentries com-

perm1 r

0 1 2 3 4 5 6 7 8 9 10 11 12 13 14 15

0 1 2 3 4 5 6 7 8 9 10 11 12 13 14 15

0 9 9 1 2 3 4 5 6 7 8 0 10 11 12 13 14 15

1 5 9 5 2 3 4 1 6 7 8 0 10 1.1 12 13 14 1.5

2 13 9 5 13 3 4 1 6 7 8 0 10 1.1 12 2 14 1.5

3 5 9 5 13 1 4 3 6 7 8 0 10 11 12 2 14 15

4 11 9 5 13 1 11 3 6 7 8 0 10 4 12 2 14 15

5 8 9 5 13 1 1.1 8 6

6

7

7

3

3

0

0

1.0

10

4

4

12

12

2

2

14 15

9 5 13 1 11 8 1.4 15

Trace ofJava Sample 6 16

93


Program 1.4.1 Sampling without replacement

m

m

&

public class Sample{

public static void main(String[] args){ // Print a random sample of M integers

// from 0 ... N-1 (no duplicates).int M = Integer.parselnt(args[0]);int N = Integer.parselnt(args[1]);int[] perm = new int[N];

// Initialize perm[].for (int j = 0; j < N; j++)

perm[j] = j;

// Take sample.for (int i = 0; i < M; i++){ // Exchange perm[i] with a random element to its right.

int r = i + (int) (Math.random() * (N-i));int t = perm[r];perm[r] = perm[i];perm[i] = t;

}

// Print sample.for (int i = 0; i < M; i++)

System.out.print(perm[i] + " ");System.out.pri ntln();

}

M

N

perm[]

sample sizerange

permutation ofOtoN-'^^s^K^PP^^^^^B^^^I^

This program takes two command-line arguments MandNandproduces a sample ofM of theintegers from 0 to N-1. This process is useful, notjust in state and local lotteries, hutin scientific applications ofall sorts. If the first argument is equal to the second, theresult is a randompermutation of theintegers from 0 to N-1. If the firstargument isgreater than thesecond, theprogram will terminate with an ArrayOutOfBounds exception.

% Java Sample 6 169 5 13 1 11 8

% Java Sample 10 1000656 488 298 534 811 97 813 156 424 109

% Java Sample 20 206 12 9 8 13 19 0 2 4 5 18 1 14 16 17 3 7 11 10 15

"wmmwmmmmmBmmmmm W^^Wf^f^^^^^^^'^^s^^ffTS?5SP7^*S5"

7.4 Arrays 95

prise a random sample. The accompanying trace of the contents of the perm[]array at the end of each iteration of the main loop (for a run where the valuesof Mand N are 6 and 16, respectively) illustrates the process.

If the valuesof r are chosen such that eachvaluein the givenrange is equallylikely, then perm[0] through perm[M-l] are a random sample at the end of theprocess (even though some elements might move multiple times) because eachelement in the sample is chosen by taking each item not yet sampled, with equalprobability for each choice. One important reason to explicitly compute the permutation is that we can use it to print out a random sample of any array by usingthe elements of the permutation as indices into the array. Doing so is often an attractive alternative to actually rearranging the array because it may need to be inorder for some other reason (for instance,a companymight wish to draw a randomsample from a list of customers that is kept in alphabetical order). To see how thistrick works, suppose that we wish to draw a random poker hand from our deck []array, constructed as just described. We use the code in Sampl e with N = 52 and M= 5 and replace perm[i] with deck[perm[i]] in the System.out.print() statement (and change it to pri ntl n()), resultingin output such as the following:

3 of Clubs

Jack of Hearts

6 of SpadesAce of Clubs

10 of Diamonds

Samplinglike this is widelyused as the basisfor statistical studies in polling, scientific research,and many other applications,wheneverwewant to draw conclusionsabout a largepopulation by analyzing a smallrandom sample.

Precomputed values. One simple application of arrays is to save values that youhave computed, for later use. As an example, suppose that you are writing a program that performs calculations using small values of the harmonic numbers (seeProgram 1.3.5).An efficient approach is to save the values in an array, as follows:

double[] H = new double[N];for (int i =1; i < N; i++)

H[i] = H[i-1] + 1.0/i;

Then you can just use the code H[i ] to referto anyof the values.Precomputing values in this way is an example of a space-time tradeoff, by investing in space (to save


the values) we save time (since we do not need to recompute them). This methodis not effective if we need values for huge N, but it is very effective if we need valuesfor small Nmany different times.

Simplifying repetitive code. As an example of another simpleapplication of arrays, consider the following code fragment, which prints out the name of a monthgiven its number (1 for January,2 for February,and so forth):

"Dan")"Feb")"Mar")"Apr")"May")"Jun")"Dul")"Aug")"Sep")"Oct")"Nov")"Dec")

We could also use a switch statement, but a much more compact alternative is touse a Stri ng array consisting of the names of each month:

String[] months ={

"", "Jan", "Feb", "Mar", "Apr", "May", "Jun","Jul", "Aug", "Sep", "Oct", "Nov", "Dec"

};System.out.pri ntln(months[m]);

This technique would be especially useful if you needed to access the name of amonth by its number in severaldifferent places in your program. Note that we intentionally waste one slot in the array (element 0) to make months [1] correspondto January,as required.

Assignments andequality tests. Suppose thatyouhave created the twoarrays a[]and b[]. What does it mean to assign one to the other with the code a = b; ?Similarly,what does it mean to test whether the two arrays are equal with the code (a== b) ?The answers to these questions may not be what you first assume, but if youthink about the array memory representation, you will see that Java'sinterpretation

if (m == 1) System.out.pri ntln(else if (m == 2) System.out.pri ntln(else if (m == 3) System.out.pri ntln(else if (m == 4) System.out.pri ntln(else if (m == 5) System.out.pri ntln(else if (m == 6) System.out.pri ntl n(else if (m == 7) System.out.pri ntl n(else if (m == 8) System.out.pri ntln(else if (m == 9) System.out.pri ntln(else if (m == 10) System.out.pri ntln(else if (m == 11) System.out.pri ntln(else if (m == 12) System.out.pri ntln(

IA Arrays 97

of these operations makes sense:An assignment makes the names a and b refer tothe same array. The alternative would be to have an implied loop that assigns eachvalue in b to the corresponding value in a. Similarly, an equality test checkswhetherthe two names refer to the same array.The alternativewould be to have an impliedloop that tests whether each value in one array is equal to the corresponding valuein the other array. In both cases, the implementation in Java is very simple: it justperforms the standard operation as if the array name were a variable whose valueis the memory address of the array. Note that there are many other operationsthat you might want to perform on arrays: for example, it would be nice in someapplications to say a = a + b and have it mean "add the corresponding elementin b[] to each element in a[]," but that statement is not legal in Java. Instead, wewrite an explicitloop to perform all the additions.Wewill consider in detail Java'smechanism for satisfyingsuch higher-levelprogramming needs in Section 3.2. Intypical applications, we use this mechanism,so we rarelyneed to use Java's assignments and equality tests with arrays.

With these basic definitions and examples out of the way, we can now consider twoapplications that both address interestingclassical problems and illustrate the fundamental importance of arrays in efficient computation. In both cases, the idea ofusingdata to index into an arrayplays a centralroleand enables a computation thatwould not otherwise be feasible.

Coupon collector Supposethat you havea shuffled deck of cards andyou turn them face up, one by one. How many cards do you need to turnup before you have seen one of each suit? How many cards do you need toturn up before seeing one of each value?These are examples of the famouscoupon collector problem. In general, suppose that a tradingcardcompany Coupon collectionissuestrading cards with N different possiblecards:how many do you haveto collectbefore you have all N possibilities, assuming that each possibility is equally likely for each card that you collect?

Coupon collecting isno toyproblem.Forexample, it isveryoften the casethatscientists want to know whether a sequence that arises in nature has the same characteristics as a random sequence. If so, that fact might be of interest; if not, furtherinvestigation may be warranted to look for patterns that might be of importance.For example, such tests are used by scientists to decide which parts of genomesare worth studying. One effective test for whether a sequence is truly random is


Program L4.2 Coupon collector simulation

public class CouponCollector{

public static void main(String[] args){ // Generate random values in (0..N] until finding each one.

int N = Integer.parselnt(args[0]);boolean[] found = new boolean[N];int cardcnt = 0, valcnt = 0;while (valcnt < N){ // Generate another value.

int val = (int) (Math.random() * N);cardcnt++;if (!found[val])

{valcnt++;found[val] = true;

}} // N different values found.System.out.pri ntln(cardcnt);

}}

N range

cardcnt values generated

valcnt different values found

found [] table offound values

This program simulates coupon collection bytaking a command-line argument Nandgenerating random numbers between 0 and N-1 untilgettingevery possible value.

% Java CouponCollector 10006583



•^g^Sjf^fl^^^^sg&P^ I^^^^S^^^^^^^^^^^^^^^^^^raP^^^^

the coupon collector test: compare the number of elements that need to be examined before allvalues are found againstthe corresponding number for a uniformlyrandom sequence. CouponCol 1ector (Program 1.4.2) is an example program thatsimulates this processand illustratesthe utility ofarrays. It takes the value ofN fromthe command line and generates a sequence of random integer values between 0

IA Arrays

and N— 1 using the code (i nt) (Math. randomO * N) (see Program 1.2.5). Eachvalue represents a card: for each card, we want to know if we have seen that valuebefore. To maintain that knowledge, we use an array found [], which uses the cardvalue as an index: found [i ] is true if we have seen

a card with value i and f al se if we have not. When

we get a new card that is represented by the integerval, we check whether we have seen its value beforesimply by accessing found [val ]. The computationconsists of keeping count of the number of distinctvalues seen and the number of cards generated andprinting the latter when the former gets to N.

Asusual, the best wayto understand a programis to consider a trace of the values of its variables for

a typical run. It is easy to add code to CouponCol -lector that produces a trace that gives the valuesof the variables at the end of the whi 1e loop for atypical run. In the accompanying figure, we use Ffor the value f al se and T for the value t rue to make

the trace easier to follow. Tracing programs that uselarge arrays can be a challenge: when you have anarray of sizeN in your program, it represents N variables, so you have to list them all. Tracing programsthat use Math. random() also can be a challengebecause you get a different traceevery time you run the program. Accordingly, we check relationships among variablescarefully. Here, note that val cnt always is equal to the number of t rue valuesin found [].

Without arrays, we could not contemplate simulating the coupon collectorprocess for huge N; with arrays it is easyto do so. Wewill see many examples ofsuch processes throughout the book.

99

valfound

0 12 3 4 5valcnt cardcnt

F F

F T

T F T F F F

TFT

T T T

p j r

F T F

T T T F T f

T j j F T T

TTTFTT

TTT

T T T

F T T

T T 7

0

1

2

3

3

4

4

5

5

5

6

0

1

2

3

4

5

6

7

8

9

10

Tracefor a typical run ofJava CouponCollector 6

Sieve of Eratosthenes Prime numbersplayan important role in mathematicsand computation, including cryptography. A prime number is an integer greaterthan one whose only positivedivisorsare one and itself. The prime counting function tt(JV) is the number of primes lessthan or equal to N. For example, tt(25) = 9since the first nine primes are 2,3,5,7,11,13,17,19, and 23.This function playsacentral role in number theory.


m

I

PS

Program IA3 Sieve ofEratosthenes

public class PrimeSieve{

public static void main(String[] args){ // Print the number of primes <= N.

int N = Integer.parselnt(args[0]);boolean[] isPrime = new boolean[N+l];for (int i = 2; i <= N; i++)

isPrime[i] = true;

for (int i = 2; i <= N/i; i++){ if (isPrime[i])

{ // Mark multiples of i as nonprime.for (int j = i; j <= N/i; j++)

isPrime[i * j] = false;}

}

// Count the primes.int primes = 0;for (int i =2; i <= N; i++)

if (isPrime[i]) primes++;System. out. pri ntl n (pri mes);

}

N

isPrime[i]

primes

argument

is i prime7,

prime counter I

This program takes a command-line argument Nandcomputes the number ofprimes less thanorequal to N. To doso, it computes an array ofboolean values with i sPri me [i ] set to true ifi isprime, and to fal se otherwise. First, it sets to true all array elements in order to indicatethat nonumbers are initially known to be nonprime. Then itsets tofal se array elements corresponding to indices that are known to be nonprime (multiples of known primes). I/a[i] isstill true after all multiples of smaller primes have been set to false, then we know i to beprime. The termination test in the second for loop isi <= N/i instead ofthe naive i <= Nbecause anynumber with nofactor less than N/i has nofactor greater than N/i, sowedonothaveto lookforsuch factors. This improvement makes itpossible to run the program for large N.

% Java PrimeSieve 259


% Java PrimeSieve 100000000050847534

wmmmmimmmmmmmm

^M^^S^^^^^dki^Si^Sd^^M

i

IA Arrays 101

isPrime

2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 19 20 21 22 23 24 25

T T T T T T T T T T T T T T T T T T T T T T T T

2 T T F T F T F T F T F T F T F T F T F T F T F T

3 T T F T F I F F F T F T F F F T F I F F F T F 1

5 T T F T F T F F F T F T F F F T F T F F F T F F

T T F T F T F F F T F T F F F T F T F F F T F F

Trace of Java PrimeSieve 25

One approach to counting primes is to use a program like Factors (Program1.3.9). Specifically, we could modify the code in Factors to set a boolean value tobe true if a given number is prime and fal se otherwise (instead of printing outfactors), then enclose that code in a loop that increments a counter for each primenumber. This approach is effective for small N, but becomes too slow as N grows.

PrimeSieve (Program 1.4.3) takes a command-line integer Nand computesthe prime count using a technique known as the Sieve ofEratosthenes. The programuses a boolean array isPrime[] to record which integers are prime. The goal isto set i sPri me [i ] to true if i is prime, and to fal se otherwise. The sieveworksas follows: Initially, set all array elements to true, indicating that no factors of anyinteger have yet been found. Then, repeat the followingsteps as long as i <= N/i:

• Find the next smallest i for which no factors have been found.

• Leave i sPri me[i ] as true since i has no smaller factors.• Set the i sPri me [] entries for all multiples of i to be fal se.

When the nested f or loop ends, we haveset the i s Pri me [] entries for all nonprimesto be false and have left the isPrime[] entries for all primes as true. With onemore pass through the array,wecan count the number of primes lessthan or equalto N. As usual, it is easy to add code to print a trace. For programs such as Prime-Si eve, you have to be a bit careful—it contains a nested f or-i f-for, so you haveto pay attention to the braces in order to put the print code in the correct place.Note that we stop when i > N/i, just as we did for Factors.

With PrimeSieve, we can compute tt(N) for large Ny limited primarily bythe maximum array size allowed by Java. This is another example of a space-timetradeoff. Programs like PrimeSi eve play an important role in helping mathematicians to develop the theory of numbers, which has many important applications.


Two-dimeesiomal arrays In many applications, a convenient way to store information is to use a table of numbers organized in a rectangular table and referto rows and columns in the table. For example, a teacher might need to maintaina table with a rowcorresponding to each student and a columncorresponding toeach assignment, a scientist might need to maintain a table of experimental datawith rows corresponding to experiments and columns corresponding to various outcomes, or a programmer might want a[i] [2]to prepare an image for displayby setting a table of pixels tovarious grayscalevalues or colors. row i-

The mathematical abstraction corresponding to suchtables is a matrix; the corresponding Java construct is a two-dimensional array. You are likely to have already encounteredmany applications of matrices and two-dimensional arrays,and you will certainly encounter many others in science, inengineering, and in computing applications, as we will demonstrate with examples throughout this book. Aswith vectorsand one-dimensional arrays,many of the most important ap- column iplications involve processing large amounts of data, and wedefer considering those applications until we consider input Tna omy°Ja

j ^ ^ . n - _ two-dimensional arrayand output, in Section 1.5. 7

Extending Java array constructs to handle two-dimensional arrays is straightforward. To refer to the element in row i and column j ofa two-dimensional array a[] [], we use the notation a[i ] [j]; to declare a two-dimensional array,weadd another pair of brackets;and to create the array,wespecifythe number of rowsfollowed by the number of columns after the type name (bothwithin brackets), as follows:

doubl e[][] a = new doubl e [M] [N];

We refer to such an array as an M-by-AT array. By convention, the first dimensionis the number of rows and the second is the number of columns. As with one-

dimensional arrays, Java initializes all entries in arrays of numbers to zero and inarrays of boolean values to fal se.

Initialization. Default initialization of two-dimensional arrays is useful becauseit masksmore code than for one-dimensionalarrays.The following code is equivalent to the single-linecreate-and-initialize idiom that we just considered:

99 85\ 98

|98 57 78

92 77 76

94 32 11

99 34 22

90 46 54

76 59 88

92 66 89

97 71 24

89 29 38

t

IA Arrays

doubled [] a;a = new double[M][N];for (int i = 0; i < M; i++){ // Initialize the ith row.

for (int j = 0; j < N; j++)a[i][j] = 0.0;

}

This code is superfluous when initializing to zero, but the nested for loops areneeded to initialize to some other value(s). Asyou will see,this code is a model forthe code that we use to access or modify each element of a two-dimensional array.

Output. We use nested for loops for many array-processing operations. For example, to print an M-by-AT array in the familiar tabular format, we would use thefollowing code

for (int i = 0; i < M; i++){ // Print the ith row.

for (int j = 0; j < N; j++)System.out.print(a[i][j] +

System.out.pri ntln();}

");

regardless of the array elements' type. If desired, we a^^could add code to embellish the output with row and \.column numbers (see Exercise 1.4.6), but Java programmers typically tabulate arrays with row numbersrunning top to bottom from 0 and column numberrunning left to right from 0. Generally, we also do soand do not bother to use labels.

Memory representation. Java represents a two-di- a[5]-*-mensional array as an array of arrays. A matrix withM rows and N columns is actually an array of lengthM, each entry of which is an array of length N. In atwo-dimensional Javaarray a [] [], we can use the codea[i] to refer to the ith row (which is a one-dimensional array), but we have no corresponding way torefer to a column.

103

a[0][0] a[0][l] a[0][2]

a[l][0] a[l][l] a[l][2]

a[2][0] a[2][l] a[2][2]

a[3][0] a[3][l] a[3][2]

a[4][0] a[4][l] a[4][2]

Kill

a[6][0] a[6][l] a[6][2]

a[7][0] a[7][l] a[7][2]

a[8][0] a[8][l] a[8][2]

a[9][0] a[9][l] a[9][2]

A 10-by-3 array


Setting values at compile time. TheJava methodfor initializing an array of values at compile time follows immediatelyfrom the representation. A two-dimensional array is an arrayof rows, each row initialized as a one-dimensional array. Toinitialize a two-dimensional array, we enclose in braces a listof terms to initialize the rows, separated by commas. Eachterm in the list is itselfa list: the valuesfor the array elementsin the row,enclosed in bracesand separatedby commas.

Spreadsheets. Onefamiliar use of arrays isa spreadsheet formaintaining a table of numbers. For example,a teacher withM students and N test grades for each student might maintain an (M+l)-by-(N+l) array,reservingthe last column foreach student's average grade and the last row for the averagetest grades.Even though we typically do such computationswithin specialized applications, it is worthwhile to study theunderlying code as an introduction to array processing. To compute the averagegrade for each student (average values for each row), sum the entries for each rowand divide by N. The row-by-row order in which this code processes the matrix

int[][] a =

{{ 99, 85, 98, 0 },

{ 98, 57, 78, 0 },

{ 92, 77, 76, 0 },

{ 94, 32, 11. 0 },

{ 99, 34, 22, 0 },

{ 90, 46, 54, 0 },

{ 76, 59, 88, 0 },

{ 92, 66, 89, 0 },

{ 97, 71, 24, 0 },

{ 89, 29, 38, 0 },

{ o, 0, 0, 0 }

};

Compile-time initializationof a two-dimensional array

N=3

averagesin column N

99 85 98 94

98 57 78 77

I92 77 76 81194 32 11 45

99 34 22 51

90 46 54 63

76 59 88 74

92 66 89 82

97 71 24 64

89 29 38 52

92 55 57-

92+77+76

Computerowaverages

for (int i = 0; i < M; i++){ // Compute average for row i

double sum =0.0;for (int j = 0; j < N; j++)

sum += a[i][j];a[i][N] = (int) Math.round(sum/N);

}M = 10

85+57+...+29

10

columnaveragesin row M

Compute columnaverages

for (int j = 0; j < N; j++){ // Compute average for column j

double sum =0.0;for (int i = 0; i < M; i++)

sum += a[i][j];a[M][j] = (int) Math.round(sum/M);

}

Typical spreadsheet calculations

IA Arrays

entries is known as row-major order. Similarly, to compute the average test grade(average values for each column), sum the entries for each column and divide byM. The column-by-column order in which this code processes the matrix entries isknown as column-major order.

a[][]

b[][] b[l][2]

c[][] c[l][2]

Matrix addition

Matrix operations. Typical applications in science andengineering involve representing matrices as two-dimensional arrays and then implementing various mathematical operations with matrix operands. Again, eventhough such processing is often done within specializedapplications, it is worthwhile for you to understand theunderlying computation. For example, we can add twoN-by-N matrices as follows:

doubl e[][] c = new doubl e [N] [N];for (int i = 0; i < N; i++)

for (int j = 0; j < N; j++)c[i][j] = a[i][j] + b[i][j];

Similarly, we can multiply two matrices. You may havelearned matrix multiplication, but if you do not recall or

are not familiar with it, the Javacode below for square matrices is essentiallythe same as the mathematical definition. Eachentry c [i ] [j]in the product of a [] and b[] is computed by taking the dot productof row i of a [] with column j of b[].

a[][]

105

.30 .60 .101— row 1

doubl e[][] c = new doubl e [N] [N];for (int i = 0; i < N; i++){

for (int j = 0; j < N; j++){

// Compute dot product of row i and column j,for (int k = 0; k < N; k++)

c[i][j] += a[i][k]*b[k][j];}

}

The definition extends to matrices that are not necessarilysquare (seeExercise 1.4.17).

b[][]column 2

C[][]

Matrix multiplication

'.5

M

-.4


Special cases ofmatrix multiplication. Two special cases ofmatrixmultiplicationare important. These special casesoccur when one of the dimensions of one of thematrices is 1, so it may be viewed as a vector.We have matrix-vector multiplication^where we multiply an M-by-N matrix by a column vector (an N-by-1 matrix) to get

an M-by-1 column vector result (each entryin the result is the dot product of the corresponding row in the matrix with the operand vector). The second case is vector-matrixmultiplication^ where we multiply a row vector(a 1-by-M matrix) by an M-by-N matrix toget a 1-by-N row vector result (each entry inthe result is the dot product of the operandvector with the corresponding column in thematrix). These operations provide a succinctwayto express numerous matrix calculations.For example, the row-average computationfor such a spreadsheet with M rows and Ncolumns is equivalent to a matrix-vectormultiplication where the column vector hasM entries all equal to 1/M. Similarly, the column-average computation in such a spreadsheet is equivalent to a vector-matrix multiplication where the row vector has N entriesall equal to 1/N. We return to vector-matrixmultiplication in the context of an importantapplication at the end of this chapter.

Matrix-vectormultiplication a[] []*x [] = b[]

for (int i =0; i < M; i++){ // Dot product of row i and x[],

for (int j = 0; j < N; j++)a[i][j]*x[j];

}b[i] +-

a[][] b[]

~99 85 98 ~94~98 57 78 77

92 77 76 x[] 81

94 32 11 45

99 34 22 .33 51

90 46 54 .33 63

76 59 88 .33 74

92 66 89 82

97 71 24 64

89 29 38 52

row

averages

Vector-matrix multiplication y[]*a[][] = c[]

for (int j = 0; j < N; j++){ // Dot product of y[] and column

for (int i = 0; i < M; i++)c[j] +- y[i]*a[i][j];

}

y[] [ .1 .1 .1 .1 .1 .1 .1 .1 .1 .1 ]

a[][]

3-

99 85 98

98 57 78

92 77 76

94 32 11

99 34 22

90 46 54

76 59 88

92 66 89

97 71 24

89 29 38

c[] [92 55 57]columnaverages

Matrix-vector and vector-matrix multiplication

Ragged arrays. There isactually no requirement that all rows in a two-dimensional arrayhave the same length—an array with rows ofnonuniform length is known as a ragged array(see Exercise 1.4.32 for an example application). The possibility of ragged arrays createsthe need for more care in crafting array-processing code. For example, this code printsthe contents of a ragged array:

IA Arrays

for (int i = 0; i < a.length; i++){

for (int j = 0; j < a[i].length; j++)System, out. print (a [i][j] + " ");

System.out.pri ntln();}

This code tests your understanding of Java arrays, so you should take the time tostudy it. In this book, we normally use square or rectangulararrays,whose dimension is givenby a variable Mor N. Code that uses a [i ]. 1ength in this way is a clearsignal to you that an array is ragged.

Multidimensional arrays. The same notation extends to allow us to write codeusing arrays that haveany number of dimensions.For instance,we can declare andinitializea three-dimensional array with the code

doubled [][] a = new double[N] [N] [N];

and then refer to an entry with code like a [i ] [ j ] [k], and so forth.

Two-dimensional arrays provide a natural representation for matrices, which are

omnipresent in science,mathematics, and engineering. They also provide a naturalway to organize large amounts of data, a key factor in spreadsheets and many othercomputing applications. Through Cartesian coordinates, two- and three-dimensional arrays also provide the basis for a models of the physicalworld. We considertheir use in all three arenas throughout this book.

dead end

escape

107

Example: self-avoiding random walks Suppose that you leaveyour dog in the middle of a large city whose streets form a familiar gridpattern. We assume that there are N north-south streets and N east-weststreets all regularly spaced and fully intersecting in a pattern known as alattice. Trying to escape the city,the dog makes a random choice of whichway to go at each intersection, but knows by scent to avoid visiting anyplace previously visited. But it is possible for the dog to get stuck in adead end where there is no choice but to revisit some intersection. What

is the chance that this will happen? This amusing problem is a simpleexample of a famous model known as the self-avoiding random walk,which has important scientificapplications in the study of polymers andin statistical mechanics, among many others. For example, you can see Self-avoiding walks


that this processmodels a chain of material growing a bit at a time, until no growthis possible. To better understand such processes, scientists seek to understand theproperties of self-avoidingwalks.

The dog's escape probability is certainly dependent on the size of the city. Ina tiny 5-by-5 city, it is easy to convince yourself that the dog is certain to escape.But what are the chances of escape when the city is large?We are also interested inother parameters. For example, how long is the dog's path, on the average? Howoften does the dog come within one block of a previous position other than theone just left, on the average? How often does the dog come within one block ofescaping? These sorts of properties are important in the various applications justmentioned.

Sel f Avoi di ngWal k (Program 1.4.4) is a simulation of this situation that usesa two-dimensional bool ean array,where each entry represents an intersection. Thevalue true indicates that the dog has visited the intersection; fal se indicates thatthe dog has not visited the intersection. The path starts in the center and takes random steps to placesnot yet visiteduntil getting stuck or escaping at a boundary. Forsimplicity,the code is written so that if a random choice is made to go to a spot thathas already been visited, it takes no action, trusting that some subsequent randomchoice will find a new place (which is assured because the code explicitly tests for adead end and leaves the loop in that case).

Note that the code depends on Javainitializing all of the array entries to fal sefor each experiment. It also exhibits an important programming technique wherewe code the loop exit test in the whi 1e statement as a guard against an illegalstatement in the body of the loop. In this case, the whi1e loop continuation test servesas a guard against an out-of-bounds array access within the loop. This correspondsto checking whether the dog has escaped. Within the loop, a successful dead-endtest results in a break out of the loop.

As you can see from the sample runs, the unfortunate truth is that your dogis nearly certain to get trapped in a dead end in a large city. If you are interested inlearning more about self-avoidingwalks,you can find several suggestions in the exercises. For example, the dog is virtually certain to escape in the three-dimensionalversion of the problem. While this is an intuitive result that is confirmed by ourtests, the development of a mathematical model that explains the behavior of self-avoiding walks is a famous open problem: despite extensive research, no one knowsa succinct mathematical expressionfor the escapeprobability, the averagelength ofthe path, or any other important parameter.

1.4 Arrays 109

P

1

1%

;Vji»:

A^i^^Sl^^fil '0$4W)t^!k

>^?pl^"^p'sjiiiiii»

Program IAA Self-avoiding random walks

public class SelfAvoidingWalk{

public static void main(String[] args)

{ // Do T random self-avoiding walks//int

int

int

for

{

in an N-by-N latticeN = Integer.parselnt(args[0]);T = Integer.parselnt(args[1]);deadEnds = 0;(int t = 0; t < T; t++)

boolean[][] a = new boolean[N][N]int x = N/2, y = N/2;while (x > 0 && x < N-1 && y > 0

N

T

deadEnds

a[][]

x, y

lattice size

number of trials

trials resulting in a deadend

intersections visited

currentposition

random number in (0, 1)

}

{ // Check for dead end and make aa[x][y] = true;if (a[x-l][y] && a[x+l][y] && a[x] [y-1] && a[x][y+l]){ deadEnds++; break; }double r = Math.random();if (r < 0.25) { if (!a[x+l][y])else if (r < 0.50) { if (!a[x-l][y])else if (r < 0.75) { if (!a[x] [y+1])else if (r < 1.00) { if (!a[x] [y-1])

}}System.out.println(100*deadEnds/T + "% dead ends");

&& y < N-1)random move.

x++; }x—; }y++;

y—;

}}

This program takes command-line arguments NandT andcomputes T self-avoiding walks inan N-by-N lattice. For each walk, it creates a boolean array, starts the walk in thecenter, andcontinues untileither a dead endora boundary is reached. The result of thecomputation is thepercentage ofdeadends. Asusual, increasing the number ofexperiments increases theprecisionof the results.

% Java SelfAvoidingWalk 5 1000% dead ends





W^m^^^lw^ww^^^W^^W^^^^

!






'^^^W^J^w^m^^^^^^^^^'^^W^^^^^&^^^!'


! Jjl.r Tti

i- Ti.

.1.

£

±t •?

"it Is^*3r' • i-±'

uii I !:f •

-J-T. H i—f iF?; ~:J ft *t T:

B P#:EifiEjim

:Bjf:| illt4

M#W --+•

IwjjRj-.iJTntH"}: -flni||i4-H--

ffljl iWiUH--.

11::|±|x:x -T-Ttfrt

\ujk.-fin ttRffir::ifS

i Til"

TtPlttft"ffjfS

..±LL1|- [•#•+HttitHi

•U.|±{.|.1I1 -t4^ -t4- -rf--.±:=-:o:

| j-4.

:t:t:h

. i—• || is t:5'f-J-W-M+^f

RBit".t,1.|.lli|'"±tSi +tffi[-:iHTHl •

5l"I -fifHrr-:

l.faitr{.|'|hfMt'

::»i TT-IRM l rr

"t:t"'" rtT«' • v

::ffi1;i *:.t:

•HiHiHItlil11 I! i t! tit !-H-fi-t-T -r:+-

"is -r-r

.*.t-

*it iii ji It"Ti RIP H_

mttffifr mfj:: . .ff»,|l|,|..jj,..|,nII HI x' t-*vi M:.DI4I .... .i.. 4. - jiuiiii.

±ltHj : :x -

WW-ftUfftyrnHii*H

Self-avoiding random walks in a 21-by-21 grid

:ni-SKBX -r-iitiisP

"X* TI"X T-iiniH-xn

-:--HHHIf-

.j.

-L.-r

-

,

t

iiiillllfflS::

IA Arrays 111

Summary Arrays are the fourth basic element (after assignments, conditionals,and loops) found in virtually everyprogramming language, completing our coverage of basic Java constructs. As you have seen with the sample programs that wehave presented, you can write programs that can solve all sorts of problems usingjust these constructs.

Arrays are prominent in many of the programs that we consider, and the basicoperations that we have discussedhere will serveyou wellin addressing many programming tasks. When you are not using arrays explicitly(and you are sure to bedoing so frequently),you willbe using them implicitly, becauseall computers havea memory that is conceptually equivalent to an indexed array.

The fundamental ingredientthat arrays add to our programsis a potentiallyhugeincrease in the size of a program's state. Thestateof a program can be definedas the information you need to knowto understandwhat a program is doing. In aprogram without arrays, if you know the values of the variables and which statement is the next to be executed, you can normally determine what the programwill do next.When we trace a program, we are essentially tracking its state.Whena program uses arrays, however, there can be too huge a number of values (each ofwhichmight be changedin eachstatement)for us to effectively track them all. Thisdifference makes writing programs with arrays more of a challenge than writingprograms without them.

Arrays directly represent vectors and matrices, so they are of direct use incomputations associatedwith many basicproblemsin science and engineering.Arrays also provide a succinct notation for manipulating a potentially huge amountof data in a uniform way, so they playa criticalrole in anyapplication that involvesprocessinglarge amounts of data, as you willsee throughout this book.


Q. SomeJava programmersuse i nt a [] insteadof i nt [] a to declarearrays.What'sthe difference?

A. In Java, both are legaland equivalent. The former is how arrays are declared inC. The latter is the preferred style in Java sincethe type of the variable i nt [] moreclearly indicates that it is an array of integers.

Q. Whydo arrayindices start at 0 insteadof 1?

A, This convention originated with machine-language programming, where theaddress of an arrayelementwouldbe computedbyadding the indexto the addressof the beginning of an array. Starting indices at 1 would entail either a waste ofspace at the beginningof the arrayor a waste of time to subtract the 1.

Q. What happens if I use a negative number to index an array?

A, The same thing as when you use an index that is too big.Whenever a programattempts to index an array with an index that is not between zero and the arraylength minus one, Java willissue an ArraylndexOutOfBoundsException and terminate the program.

Q. What happens when I compare two arrays with (a == b)?

A. The expression evaluates to t rue onlyif a [] and b[] referto the samearray,notif they have the same sequenceof elements. Unfortunately, this is rarelywhat youwant.

Q. If a[] is an array,why does System.out. pri ntl n(a) print out a hexadecimalinteger,like @f62373 , instead of the elements of the array?

A. Good question. It is printing out the memory address of the array, which, unfortunately, is rarely what you want.

Q. What other pitfalls should I watch out for when using arrays?

A. It is very important to remember that Java always initializes arrays when youcreate them, so that creating an array takes timeproportional to thesizeof thearray.

Exercises

1.4.1 Write a program that declares and initializes an array a [] of size1000 andaccesses a [1000]. Does your program compile?What happens when you run it?

1.4.2 Describe and explainwhat happens when you try to compile a programwith the following statement:

int N = 1000;int[] a = new int[N*N*N*N];

1.4.3 Given two vectors of length Nthat are represented with one-dimensionalarrays, write a code fragment that computes the Euclidean distance between them(the squareroot of the sumsof the squares of the differences between corresponding entries).

1.4.4 Writea code fragment that reverses the order of a one-dimensional arraya [] of St ri ngvalues. Do not create another arrayto hold the result. Hint: Usethecode in the text for exchangingtwo elements.

1.4.5 What is wrong with the following code fragment?

int[] a;for (int i =0; i < 10; i++)

a[i] = i * i;

Solution. It does not allocate memory for a[] with new. This code results in avariable a might not have been initialized compile-timeerror.

1.4.6 Write a code fragment that prints the contents of a two-dimensional boolean array, using * to represent true and a spaceto represent fal se. Include row andcolumn numbers.

1.4.7 What does the following code fragment print?

int[] a = new int[10];for (int i =0; i < 10; i++)

a[i] = 9 - i;for (int i = 0; i < 10; i++)

a[i] = a[a[i]];for (int i = 0; i < 10; i++)

System.out.pri ntln(a[i]);


1.4.8 What values does the following code put in the array a [] ?

int N = 10;int[] a = new int[N];a[0] = 1;a[l] = 1;for (int i = 2; i < N; i++)

a[i] = a[i-l] + a[i-2];

1.4.9 What does the following code fragment print?

int[] a = { 1, 2, 3 };int[] b = { 1, 2, 3 };System.out.println(a == b);

1.4.10 Write a program Deal that takesan command-line argument Nand printsNpoker hands (five cards each) from a shuffleddeck, separated by blank lines.

1.4.11 Write code fragments to create a two-dimensional array b[] [] that is acopy of an existing two-dimensional array a[] [], under each of the following assumptions:

a. a[] [] is square

b. a[] [] is rectangular

c. a [] [] may be raggedYoursolution to b should work for a, and your solution to c should work for bothband a, but your code should get progressively more complicated.

1.4.12 Write a code fragment to print the transposition (rows and columnschanged) of a square two-dimensional array.For the example spreadsheet array inthe text, you code would print the following:

99 98 92 94 99 90 76 92 97 89

85 57 77 32 34 46 59 66 71 29

98 78 76 11 22 54 88 89 24 38

1.4.13 Write a code fragment to transpose a square two-dimensional array inplacewithout creating a second array.

1.4 Arrays

1.4.14 Write a program that takes an integerN from the command line and creates an N-by-Nboolean array a[] [] such that a[i ] [j] is true if i and j are relatively prime (have no common factors), and fal se otherwise. Use your solution toExercise 1.4.6to print the array.Hint Usesieving.

1.4.15 Write a program that computes the product of two square matrices ofbooleanvalues, using the oroperation instead of + and the and operation insteadof*.

1.4.16 Modify the spreadsheet code fragment in the text to compute a weightedaverage of the rows,where the weights of each test scoreare in a one-dimensionalarrayweights []. For example, to assign the lastof the three tests in our exampletobe twicethe weight of the others, you would use

double[] weights = { .25, .25, .50 };

Note that the weights should sum to 1.

1.4.17 Write a code fragment to multiply two rectangular matrices that are notnecessarily square.Note: For the dot product to be well-defined, the number of columns in the first matrix must be equal to the number of rowsin the second matrix.Print an error message if the dimensions do not satisfy this condition.

1.4.18 Modify Sel fAvoi di ngWal k (Program 1.4.4) to calculate and print the average length of the paths as well as the dead-end probability. Keep separate theaverage lengths of escapepaths and dead-end paths.

1.4.19 Modify Sel fAvoi di ngWal k to calculate and print the average area of thesmallest axis-oriented rectangle that encloses the path. Keep separate statistics forescape paths and dead-end paths.

115


1.4.20 Dicesimulation. The following code computes the exactprobability distribution for the sum of two dice:

double[] dist = new double[13];for (int i = 1; i <= 6; i++)

for (int j = 1; j <= 6; j++)dist[i+j] += 1.0;

for (int k = 1; k <= 12; k++)

dist[k] /= 36.0;

The value di st [k] is the probability that the dice sum to k. Run experiments tovalidate this calculation simulating N dice throws, keeping track of the frequenciesof occurrence of each value when you compute the sum of two random integersbetween 1 and 6. How large doesN haveto be before your empirical results matchthe exact results to three decimal places?

1.4.21 Longestplateau. Given an arrayof integers, find the length and locationofthe longest contiguous sequence of equal values where the values of the elementsjust before and just after this sequenceare smaller.

1.4.22 Empirical shuffle check. Run computational experiments to checkthat ourshuffling codeworksas advertised. Writea program Shuff1eTest that takescommand-line arguments M and 1ST, doesN shuffles of an array of sizeM that is initialized with a [i ] = i before each shuffle, and prints an M-by-M table such that rowi gives the number of times i wound up in position j for all j. All entries in thearray should be close to N/M.

1.4.23 Bad shuffling. Suppose that you choose a random integer between 0 andN-1in our shuffling code insteadof one betweeni and N-1. Showthat the resultingorder is notequallylikelyto be one of the N! possibilities.Run the test of the previous exercise for this version.

1.4.24 Music shuffling. You setyour musicplayerto shufflemode. It playseach ofthe N songs before repeating any. Write a program to estimate the likelihood thatyou will not hear any sequential pair of songs (that is, song 3 does not followsong2, song 10 does not follow song 9, and so on).

IA Arrays

1.4.24 Minima in permutations. Write a program that takes an integer Nfromthe command line, generates a randompermutation, prints the permutation, andprints the number of left-to-rightminimain thepermutation(thenumber of timesan element is the smallest seen sofar). Then write a program that takes integers Mand Nfrom the command line, generates Mrandom permutations of size N, andprints the average number of left-to-right minima in thepermutations generated.Extra credit: Formulate a hypothesis about thenumber of left-to-right minima ina permutation of size N, as a function of N.

1.4.25 Inverse permutation. Write a program that reads in a permutation of theintegers 0 to N-1 from Ncommand-line arguments and prints the inverse permutation. (If the permutation is in an array a[], its inverse is the array b[] such thata [b[i ] ] = b[a [i ] ] = i.) Besure to check that the input is a validpermutation.

1.4.26 Hadamard matrix. The N-by-NHadamardmatrixH(N) is a boolean matrix with the remarkable property that any two rows differ in exactly N/2 entries.(This property makes it useful for designing error-correcting codes.) H(l) is a1-by-lmatrix withthesingle entrytrue, andfor AT>1, H(2N) isobtained byaligningfourcopies ofH(N) in a large square, andtheninverting allof the entries in thelower right N-by-N copy, as shown inthefollowing examples (with Trepresentingtrue and Frepresenting fal se, as usual).

H(l) H(2) H(4)T T T T T T T

T F T F T F

T T F F

T F F T

Write a program that takes one command-line argument N and prints H(N). Assume that JV is a power of 2.

1.4.27 Rumors. Alice isthrowing a partywithN otherguests, including Bob. Bobstartsa rumor aboutAlice bytelling it to oneof the otherguests. Apersonhearingthis rumor for the first time will immediately tell it to one other guest, chosen atrandom from all the people at the party except Alice and the person from whom

117


theyheard it. If a person (including Bob) hears the rumorfor a second time, he orshe will not propagate it further. Write a program to estimate the probability thateveryone at theparty(except Alice) will hear therumorbefore it stops propagating.Also calculate an estimateof the expected number of peopleto hear the rumor.

1.4.28 Find a duplicate. Given an array of Nelements witheach element between1 and N, write an algorithm to determine whether thereareanyduplicates. You donot needto preserve the contents of the given array, but do not usean extraarray.

1.4.29 Countingprimes. Compare PrimeSi eve withthe method that we used todemonstrate the break statement, at the end of Section 1.3.This is a classicexampleof a time-space tradeoff: PrimeSieve is fast, but requires a boolean array of sizeN; the other approach uses only two integer variables, but is substantially slower.Estimate the magnitude of thisdifference byfinding the value of N for which thissecond approach can complete the computation in about the same time as JavaPrimeSeive 1000000.

1.4.30 Minesweeper. Write a programthat takes 3 command-line argumentsM,N,andp andproduces anM-by-Nboolean array where each entryisoccupied withprobabilityp.In theminesweeper game, occupied cells represent bombs andemptycells represent safe cells. Printoutthearray using anasterisk forbombs andaperiodforsafe cells. Then, replace each safe square withthenumberofneighboring bombs(above, below, left, right,or diagonal) and print out the solution.

* * . . . * * 1 0 0

3 3 2 0 0

. * . . . 1*10 0

Try towrite your code sothatyou have as few special cases as possible to deal with,by using an (M+2)-by-(N+2) boolean array.

1.4.31 Self-avoiding walk length. Suppose that there is no limiton the size of thegrid. Runexperiments to estimate the average walk length.

1.4.32 Three-dimensional self-avoiding walks. Run experiments to verifythat thedead-end probability is 0 for a three-dimensional self-avoiding walk and to compute the average walklength for variousvalues of N.

IA Arrays

1.4.33 Random walkers. Suppose that N random walkers, starting in the centerof an N-by-Ngrid, move one step at a time, choosing to goleft, right,up,or downwith equalprobability at each step. Write a programto help formulate and test ahypothesisabout the number of stepstakenbeforeall cells are touched.

1.4.34 Bridge hands. In the game of bridge, four players are dealt hands of 13cards each.An important statistic is the distribution of the number of cards in eachsuit in a hand. Which is the most likely, 5-3-3-2,4-4-3-2, or 4-3-3-3?

1.4.35 Birthday problem. Suppose that people enter an empty room until a pairof people share a birthday. On average, howmany people will have to enterbeforethere is a match? Run experiments to estimate the value of this quantity. Assumebirthdays to be uniform random integers between 0 and 364.

1.4.36 Coupon collector. Run experiments to validate the classical mathematicalresult that the expected number of coupons needed to collect N values is aboutNHN. For example, if you are observing the cards carefully at the blackjack table(andthe dealer hasenough decks randomly shuffled together), youwill waituntilabout 235 cards aredealt, on average, before seeing every cardvalue.

1.4.37 Binomial coefficients. Write a program thatbuilds andprints a two-dimensional ragged array a such thata[N] [k] contains theprobabilitythatyougetexactlykheads when you toss a coin Ntimes. Take acommand-line argument to specify themaximum value of N. These numbers areknown asthe binomial distribution: ifyoumultiply each entryin rowi by2N, yougetthe binomial coefficients (thecoefficientsofxk in (x+l)*) arranged in Pascal's triangle. To compute them,start with a[N] [0]= 0forall Nanda[1] [1] = 1,thencompute values in successive rows, leftto right,witha[N][k] = (a[N-l][k] + a[N-l] [k-l])/2.

Pascal's triangle binomial distribution

l l

l l 1/2 1/2

12 1 1/4 1/2 1/4

13 3 1 1/8 3/8 3/8 1/8

14 6 4 1 1/16 1/4 3/8 1/4 1/16

119


1.5 Input and Output

In this section weextend the set of simpleabstractions (command-line input andstandard output) that we have been using as the interfacebetween our Java programs and the outside world to includestandard input, standard drawing, and 1.5.1 Generating arandom sequence. .. 122standard audio. Standard input makes it 1.5.2. Interactive user input....... ,129convenient for us to write programs that l33 Averaging astream ofnumbers. . .130

,. x r • . j 1.5.4 Asimplefilter 134process arbitrary amounts of input and l55 Input:t0.drawingfiiter 139to interact with our programs; standard L5m6 Bouncing ball 145drawing makes it possible for us to work 1.5.7 Digital signal processing 150with graphical representations ofimages, Programs in this sectionfreeing us from having to encode everything as text; and standard audio addssound. Theseextensions are easyto use,and you willfind that they bring you to yetanother new world of programming.

The abbreviation I/O is universally understood to mean input/output, a collective term that refers to the mechanisms by which programs communicatewiththe outsideworld. Your computer's operatingsystem controls the physical devicesthat are connected to your computer. To implementthe standard I/O abstractions,we use libraries of methods that interface to the operating system.

You have already been accepting argument values from the command lineandprinting strings in a terminal window; thepurpose of thissection isto provideyou with a much richer set of tools for processing and presenting data. Like theSystem, out. pri nt() and System,out. pri ntl n() methods that you have beenusing, these methods do not implement mathematical functions—their purposeisto cause some side effect, either on an input deviceor an output device.Our primeconcernis usingsuch devices to getinformationinto and out of our programs.

An essential feature of standard I/O mechanisms is that there is no limit onthe amount of input or output data, from the point of view of the program. Yourprograms can consume input or produce output indefinitely.

One use of standard I/O mechanisms is to connect your programs to filesonyour computer's disk. It is easy to connectstandard input, standard output, standard drawing, and standard audio to files. Such connections make it easyto haveyour Java programs save or load results to files for archival purposes or for laterreference by other programs or other applications.


Bird's-eye view Theconventional model that we have beenusing for Java programming has served us since Section 1.1. To build context, we begin by brieflyreviewing the model.

AJava program takes input values fromthe commandlineand prints a stringof characters as output. Bydefault, both command-line input and standard outputare associated with the application that takes commands (the one in which youhave been typingthe Java and javac commands). We usethe generic term terminalwindow to refer to this application. This modelhas proven to be a convenientand directwayfor us to interactwith our programs and data.

Command-line input. This mechanism, which we have been using to provideinput values to our programs, is a standard part of Java programming. Allclasseshave a mai n() method that takes a St ri ng arrayargs [] as its argument. That arrayis the sequence of command-line arguments that we type, provided to Java bythe operating system. By convention, both Java and the operating system processthe arguments as strings, so if we intend for an argument to be a number, we usea method such as Integer.parselnt() or Double.parseDoubleO to convert itfrom Stri ngto the appropriate type.

Standard output. To print output values in our programs, we have been usingthe system methods System. out. pri ntl n() and System. out. pri nt (). Java putsthe results of a program's sequence of calls on these methods into the form of anabstract stream of characters known as standard output. By default, the operatingsystem connects standard output to the terminal window. All of the output in ourprogramsso far has been appearingin the terminalwindow.

For reference, and as a starting point, RandomSeq (Program 1.5.1) is a programthat uses thismodel. It takes a command-line argument N and produces an outputsequence of N random numbers between 0 and 1.

Nowweare going to complement command-line input and standard output withthree additional mechanisms that address their limitations and provide us with afar more useful programming model. These mechanisms give us a newbird's-eyeview of a Java programin which the program converts a standardinput streamanda sequenceof command-line arguments into a standard output stream, a standarddrawing, and a standard audio stream.


:^;j^^^

m

Program 1.5. J Generatinga randomsequence

public class RandomSeq{

public static void main(String[] args){ // Print a random sequence of N real values in [0, 1)

int N = Integer.parselnt(args[0]);for (int i = 0; i < N; i++)

System.out.pri ntln(Math.random());}

}

This program illustrates the conventional model that we have been using so farforJava programming. Ittakes acommand-line argument Nand prints N random numbers between 0and1. From the program's point ofview, there isno limit on the length ofthe output sequence.

% Java RandomSeq 10000000.2498362534343327

0.5578468691774513

0.5702167639727175

0.32191774192688727

0.6865902823177537

^lllllSPPI^PSiKllll^SPPwi^PPr^S^^TJ^f^jW^

1W

Standard input. Our class Stdin is a library that implements a standard inputabstraction to complement the standard output abstraction. Just asyou can printavalueto standard output at anytime duringthe executionof your program, youcan read a value from a standard input stream at any time.

Standard drawing. Our class StdDraw allows you to create drawings with yourprograms. It uses a simple graphics modelthat allows you to create drawings consisting of pointsand lines in a windowon your computer. StdDraw also includesfacilities for text, color, and animation.

Standard audio. Our class StdAudio allows you to create sound with your programs. It usesa standard format to convert arrays of numbers into sound.


Touseboth command-line input and standardoutput, youhavebeen usingbuilt-inJava facilities. Java alsohas built-in facilities that support abstractionslikestandardinput, standarddraw, and standardaudio,but theyaresomewhat more complicatedto use, so we have developed a simpler interfaceto them in our Stdin, StdDraw, and StdAudi o libraries.Tologically complete our programmingmodel, we also include a StdOut library. To usethese libraries, download Stdin. Java, StdOut.Java, StdDraw. Java, and StdAudio. Java andplace them in the same directory as your program (or use one of the other mechanisms forsharing libraries described on the booksite).

The standard input and standard outputabstractions date back to the development ofthe Unix operating system in the 1970s and arefound in some form on all modern systems. Although they are primitive by comparison to various mechanisms developed since, modern programmers stilldepend on them as areliable way to connectdata to programs. We have developed for thisbookstandarddraw and standard audio in the same spirit asthese earlier abstractions to provideyou with an easy wayto producevisual and aural output.

123

standard input [• command-linearguments

| standard output

standard audio

standarddrawing

A bird's-eye viewofa Java program (revisited)

Standard output Java's System,out. print() and System,out. pri ntl n()methods implement the basic standard output abstraction that we need. Nevertheless, to treat standard input and standard output in a uniform manner (andto provide a few technical improvements), starting in this section and continuingthrough the rest of the book, we use similar methods that are defined in our StdOutlibrary. StdOut.print () and StdOut.printlnO are nearly the same as the Javamethods that you havebeen using (seethe booksitefor a discussion of the differences,which need not concern you now).The StdOut. pri ntf () method is a maintopicof this section and will be of interest to you nowbecause it gives you morecontrol over the appearance of the output. It wasa featureof the C languageof theearly 1970s that still survives in modern languages becauseit is so useful.

Since the first time that weprinted double values, wehave been distractedbyexcessive precision in the printed output. For example,when we use System. out.print (Math. PI) we get the output 3.141592653589793, even though we might


public class StdOut

void print (St ring s) prints

void pri ntl n (String S) prints, followed bynewline

void pri ntl n() printa newline

void printf(String f, . . . ) formatted print

APIforourlibrary ofstaticmethods forstandard output

prefer to see 3.14 or 3.14159. The pri nt() and pri ntl n() methods present eachnumber to 15 decimal places evenwhen we would be happy with just a few digitsof precision. The printf() method is more flexible: it allows us to specify thenumberof digits andthe precision whenconverting data type values to strings foroutput. With pri ntf(), we canwrite StdOut. pri ntf("%7.5f", Math. PI) to get3.14159, and we can replace System. out. pri nt (t) with

StdOut.printf("The square root of %.lf is %.6f", c, t);

in Newton (Program 1.3.6) to get output like

The square root of 2.0 is 1.414214

Next, we describe the meaning and operationof these statements, alongwith extensions to handle the other built-in types of data.

Formatted printing basics. In its simplest form, pri ntf() takes two arguments.The first argument is a format string that describes how to convertthe secondargument into a string for output.The simplest type of format string begins with %and ends with a one-letter conversion code. The conversion codes that we use most

frequently are d (fordecimal values from Java's integer types), f (for floating-pointvalues), and s (for String values). Between the %

format and the conversion code is an integer that specifiesstring numbertoprint ^ ^ ^^ q{ ^ converted yalue (the numberStdOut. pri ntf("|%BJ1", Math. PI) of characters in the converted output string). By

/ | N^ default, blanks are added on the left to make thefield width J^ conversion code j^ Qf ^ conyerted Qutput equal tQ ^ fiddwidth; if we want the blanks on the right, we can

Anatomy ofaformatted print statement insert a minus sign before the field width. (If the


converted output string is larger than the field width, the field width is ignored.)Following the width, we have the option of including a period followed by thenumber of digits to put after the decimal point (the precision) for a doubl e valueor the number of characters to take from the beginning of the string for a St ri ngvalue. The most important thing to remember about using printf() is that theconversion code in theformat and thetypeofthecorresponding argument mustmatch.That is, Java must be able to convert from the type of the argument to the type required by the conversioncode. Everytype of datacanbe convertedto St ri ng,butif you write StdOut. pri ntf("%12d", Math.PI) or StdOut. pri ntf("%4.2f",512), you will get an II1 egal FormatConversi onExcepti on run-time error.

Format string. The first argument of pri ntf() is a String that may containcharacters other than a format string. Any partof the argumentthat is not partofaformat string passes through to the output, with the format stringreplaced by theargument value (converted to a string as specified).For example, the statement

StdOut.printf("PI is approximately %.2f\n", Math.PI);

prints the line

PI is approximately 3.14

Note that we need to explicitlyinclude the newlinecharacter \n in the argument inorder to print a new line with pri ntf().

type code

int

double

String s

typicalliteral

512

sampleformatstrings

"%14d"

"%-14d"

"%14.2f"

1595.1680010754388 "%.7f"

"%14.4e"

"%14s"

"Hello, World" "%-14s""%-14.5s"

Formatconventions for pri ntf () (seethe booksitefor manyotheroptions)

converted stringvaluesfor output

512"

'512

1595.17"

"1595.1680011"

1.5952e+03"

" Hello, World""Hello, World ""Hello

125


Multiple arguments. The pri ntf () function cantakemorethan twoarguments.In this case, the format string willhavea format specifierfor each additional argument, perhaps separated by other characters to pass through to the output. Forexample, if you were making payments on a loan, you might use code whose innerloop contains the statements

String formats = "%3s $%6.2f $%7.2f $%5.2f\n";StdOut.printf(formats, month[i], pay, balance, interest);

to print the second and subsequent linesin a table like this (seeExercise 1.5.14):

payment balance interest

Dan $299.00 $9742.67 $41.67

Feb $299.00 $9484.26 $40.59

Mar $299.00 $9224.78 $39.52

Formatted printing is convenientbecause this sort of code is much more compactthan the string-concatenation code that wehavebeen using.

Standard input Our Stdin library takesdata from a standard input stream thatmaybe empty or maycontain a sequence of valuesseparatedbywhitespace (spaces,tabs, newline characters, and the like). Each value is a St ri ng or a value from one ofJava's primitive types. One of the key features of the standard input stream is thatyour program consumes values when it reads them. Once your program has reada value, it cannot back up and read it again. This assumption is restrictive, but itreflects physical characteristics of some input devices and simplifies implementingthe abstraction. The library consists of the nine methods: i sEmptyO, readlnt(),readDoubleO, readLongO, readBooleanO, readCharO, readStringO, read-

Line(), and readAl 1() . Within the input stream model, these methods are largely self-documenting (the names describe their effect),but their precise operation isworthy of careful consideration, so wewill consider severalexamples in detail.

Typing input. When you use the Java command to invoke a Javaprogram fromthe command line, you actuallyare doing three things: issuing a command to startexecuting your program, specifying the values of the command line arguments,and beginning to define the standard input stream. The string of characters thatyou type in the terminal window after the command line is the standard inputstream. When you type characters, you are interacting with your program. The


public class Stdin

bool ean i sEmpty () true if nomore values, fal se otherwise

i nt readlnt () read a value oftype i nt

doubl e readDoubl e() read a value oftype doubl e

1ong read Long () read a value oftype long

bool ean readBool ean () read a value oftype bool ean

char readChar () read a value oftype char

Stri ng readStri ng() read a value oftype Stri ng

St ri ng readLi ne() read the rest ofthe line

Stri ng readAl 1 () read the rest ofthe text

APIfor our libraryofstatic methods for standardinput

program waits for you to create the standard input stream. Forexample, considerthe following program, which takes a command-line argument Ny then reads Nnumbers from standard input and adds them:

public class Addlnts{


int N = Integer.parselnt(args[0]);int sum = 0;for (int i = 0; i < N; i++){

int value = Stdin.readlnt();sum += value;

}StdOut.println("Sum is " + sum);

}}

When you type j ava Addlnts 4, afterthe programtakes the command-line argument, it calls the method Stdin. readlnt () and waits for you to type an integer.Suppose that you want 144 to be the first value. As you type 1, then 4, and then 4,nothing happens, because Stdin does not know that you are done typing the integer. But when you then type <return> to signify the end of your integer, Stdin.readlnt () immediately returns the value 144, which your program adds to sum


and then calls Stdin. readlnt () again. Again, nothing happens until you type thesecond value: if you type 2, then 3, then 3, and then <return> to end the number,Stdin. readlnt () returns the value 233, which your program again adds to sum.Afteryou have typed four numbers in this way, Addlnts expects no more input andprints out the sum, as desired.

Input format. If you type abc or 12.2 or true whenStdin. readlnt() is expecting an int, it will respondwith a NumberFormatException. The format for eachtype is the same as you have been using for literal values within Javaprograms. For convenience, Stdin treatsstrings of consecutive whitespace charactersas identicalto one space and allows you to delimit your numberswith such strings. It does not matter how many spacesyou put between numbers, or whether you enter numbers on one line or separate them with tab charactersor spread them out over several lines, (except that yourterminal application processesstandard input one line at a time, so it will wait until you type <return> before sending all of the numbers on that line to standardinput). Youcan mix values of different types in an input stream, but whenever theprogram expects a value of a particular type, the input stream must have a valueof that type.

Interactive user input. TwentyQuestions (Program 1.5.2) is a simple exampleof a program that interacts with its user.The program generates a random integerand then gives clues to a user trying to guessthe number. (Asa side note: by usingbinary search, you can always get to the answer in at most twenty questions. SeeSection 4.2.) The fundamental difference between this program and others thatwe havewritten is that the user has the ability to change the control flow while theprogram is executing. This capability was very important in early applications ofcomputing, but we rarely write such programs nowadays because modern applications typically take such input through the graphical user interface, as discussedin Chapter 3. Even a simple program like TwentyQuestions illustrates that writing programs that support user interaction is potentially very difficult because youhave to plan for all possible user inputs.

command line

\

command-lineargument

% Java Addlnts 4

144

233

377

1024

standard inputstream

Sum is 1778\

standard outputstream

Anatomy ofa command


m

1

m

Is

m

•^y^jy^^

Program 1.5.2 Interactive user input

public class TwentyQuestions{

public static void main(String[] args){ // Generate a number and answer questions

// while the user tries to guess the value,int N = 1 + (int) (Math.random() * 1000000);StdOut.print("Ifm thinking of a number ");StdOut.println("between 1 and 1,000,000");int m = 0;while (m != N){ // Solicit one guess and provide one answer

StdOut.print("What's your guess? ");m = Stdin.readlnt();if (m == N) StdOut.println("You win!");if (m < N) StdOut.println("Too low ");if (m > N) StdOut.println("Too high");

}}

}

hidden value

user's guess

This program plays a simple guessing game. You type numbers, each of which is an implicitquestion ("Is this the number?") and the program tells you whether your guess is too high ortoo low. You can always get it to print You wi n! with less than twenty questions. To use thisprogram, you need tofirst download Stdin .Java andStdOut.Java into the same directoryas thiscode (which is in afile named TwentyQuesti ons. javaj.

% Java TwentyQuestionsI'm thinking of a number between 1 and 1,000,000What's your guess? 500000Too highWhat's your guess? 250000Too low

What's your guess? 375000Too highWhat's your guess? 312500Too highWhat's your guess? 300500Too low

I

w^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^


Ws

M

^^^^^&2^ vMMM^,

Program 1.5.3 Averaging a stream of numbers

public class Average{

public static void main(String[] args){ // Average the numbers on the input stream.

double sum =0.0;int cnt = 0;while (!Stdin.isEmptyO){ // Read a number and cumulate the sum.

double value = Stdin. readDoubleO;sum += value;cnt++;

}double average = sum / cnt;StdOut.println("Average is " + average);

}}

cnt

sum

countof numbers readcumulated sum

This program reads ina sequence ofreal numbersfrom standard inputandprintstheir averageon standard output (provided that the sumdoes notoverflow). From itspoint of view, there isno limiton thesizeof theinputstream. The commands on theright below useredirection andpiping(discussed in thenextsubsection) toprovide 100,000 numbers to average.

% java RandomSeq 100000 > data.txtH % Java Average < data.txt

Average is 0.5010473676174824

% Java Average10.0 5.0 6.0

3.0

7.0 32.0

<ctrl-d>

Average is 10.5

?^*i?r™?^PPIP1

% Java RandomSeq 100000 | Java AverageAverage is 0.5000499417963857

jw! W^^^^^-^^W^^^^^^^^^^^^^^^'

Processing an arbitrary-size input stream. Typically, input streams are finite:your program marches through the input stream, consuming values until thestream is empty. But there is no restriction of the sizeof the input stream, and someprograms simply process all the input presented to them. Average (Program 1.5.3)is an example that reads in a sequence of real numbers from standard input andprints their average. It illustrates a keyproperty of usingan input stream:the length


of the stream is not known to the program.We type all the numbers that we have,and then the program averages them. Before reading each number, the programuses the method Stdin. i sEmpty() to checkwhether there are any more numbersin the input stream.Howdo wesignal that wehave no more data to type? Byconvention, wetypea special sequence of characters known asthe end-of-file sequence.Unfortunately, the terminal applications that we typically encounter on modernoperating systems use different conventions for this critically important sequence.In this book, we use <ctrl -d> (manysystems require <ctrl -d> to be on a line byitself); the other widelyused convention is <ctrl -z> on a line by itself. Averageis a simpleprogram, but it represents a profound newcapability in programming:with standard input, we can write programsthat process an unlimited amount ofdata.Asyou will see,writing such programs is an effective approach for numerousdata-processing applications.

Standard input is a substantial step up from the command-line input model thatwehave been using,for two reasons, as illustrated byTwentyQuesti ons and Average. First, we can interact with our program—with command-line arguments, wecan only provide data to the program before it begins execution. Second, we canread in largeamounts of data—with command-line arguments, we can only entervalues that fit on the command line. Indeed, as illustrated by Average, the amountof data canbe potentially unlimited, and manyprograms aremadesimplerby thatassumption. A third raison d'etre for standard input is that your operating systemmakes it possible to change the source of standardinput, so that you do not have totype all the input. Next, weconsider the mechanisms that enable this possibility.

Redirection and piping For many applications, typing input data as a standard input stream from the terminalwindow is untenable because our program'sprocessing power is then limitedby the amount of data that wecan type (and ourtypingspeed). Similarly, weoftenwantto save the information printed on the standard output streamfor lateruse. To address such limitations, wenext focus on theideathat standard input is an abstraction—the programjust expects its input andhas no dependence on the source of the input stream. Standardoutput is a similarabstraction. The powerof theseabstractions derives from our ability (through theoperating system) to specify various othersources forstandard input and standardoutput, such as a file, the network,or another program.Allmodern operating systems implement these mechanisms.


Redirecting standard output to afile. By adding a simple directive to the command that invokes a program,wecanredirect its standardoutput to a file, eitherforpermanent storage or for input to anotherprogram at a later time.For example,

% Java RandomSeq 1000 > data.txt

specifies that the standard output stream is not to be printed in the terminal window, but instead is to be written to a text file named data. txt. Each call to System .out. pri nt () or System. out. pri ntl n() appends text at the end of that file.In this example, the end result is a file that contains 1,000 random values. No output appears in the terminal window: it goesdirectly into the file named after the >symbol.Thus, we can saveawayinformation for later retrieval. Note that we do not

haveto changeRandomSeq (Program 1.5.1) in anywayfor this mechanism to work—it is using the standardoutput abstraction and is unaffected by our use of adifferent implementation of that abstraction. You canuse this mechanism to save output from any programthat you write. Once we have expended a significantamount of effort to obtain a result, we often want tosave the result for later reference. In a modern system,

you can save some information by using cut-and-paste or some similar mechanism that is provided by the operatingsystem, but cut-and-paste is inconvenientfor large amounts of data. By contrast, redirection is specifically designed to makeit easy to handle large amounts of data.

Redirecting from a file to standard input. Similarly, we can redirect standardinput so that Stdin readsdata from a file insteadof the terminal application:

% Java Average < data.txt

Thiscommand reads a sequence of numbers fromthe file data. txt and computestheir average value. Specifically, the <symbol is a directive that tells the operatingsystem to implement the standard input stream . . ^ ^ ^/ r t r java Average < data.txtby reading from the text file data. txt instead ofwaiting for the user to type something into theterminal window. When the program calls Stdin . readDoubl e(), the operating system readsthe value from the file. The file data. txt could

Java RandomSeq 1000 > data.txt

RandomSeq

is standard outputdata.txt

Redirecting standard outputtoafile

data.txt

standard inputOlAverage

Redirectingfrom afile tostandard input


havebeen created by any application, not just a Java program—virtually everyapplication on your computercan create textfiles. This facility to redirect from a fileto standard input enables us to create data-driven code where we can change thedataprocessed bya program withouthaving to change the program at all. Instead,we keep data in files and write programs that read from standard input.

Connecting twoprograms. The most flexible way to implement the standard input and standard output abstractions is to specify that they are implemented byour own programs! This mechanismis called piping. For example, the command

% Java RandomSeq 1000 | Java Average

specifies that the standard output for RandomSeq and the standard input stream forAverage are the same stream. The effect is as if RandomSeq were typing the numbers it generates into the terminal window whileAverage is running. This examplealso has the same effect as the followingsequence of commands:

% Java RandomSeq 1000 > data.txt% Java Average < data.txt

In this case, the file data. txt is not created. This difference is profound, becauseit removes another limitation on the size of the input and output streams that wecan process.For example,we could replace1000 in our examplewith 1000000000,even though we might not have thespace to save abillion numbers on our java *™d™s*<* 100° I Java Avera9ecomputer (we do need the time to process them, however). When RandomSeqcalls System.out.println(), a stringis added to the end of the stream; when

Average calls Stdin.readlnt(), astring is removed from the beginningof the stream. The timing of preciselywhat happens is up to the operatingsystem: it might run RandomSeq until it produces some output, and then run Average to consume that output, or it might run Average until it needs some output,and then run RandomSeq until it produces the needed output. The end result is thesame,but our programs are freed from worrying about such details because theywork solelywith the standard input and standard output abstractions.

RandomSeq

U standard output —• standard input

133

DLAverage

Piping the output ofoneprogram to the input ofanother


m

fi

Program 1.5.4 A simplefilter

public class RangeFilter{

public static void main(String[] args){ // Filter out numbers not between lo and hi.

int lo = Integer.parselnt(args[0]);int hi = Integer.parselnt(args[l]);while (!Stdin.isEmptyO){ // Process one number,

int t = Stdin.readlnt();if (t >= lo && t <= hi) StdOut.print(t + " ");

}StdOut.printlnO;

}}

lo

hi

t

lower bound of rangeupper boundof range

current number

W^^^^^x

This filter copies to the output stream the numbers from the input stream that fall inside therange given by the command-line parameters. There isno limit on the length of the streams.

% Java RangeFilter 100 400358 1330 55 165 689 1014 3066 387 575 843 203 48 292 877 65 998<ctrl-d>

358 165 387 203 292

^^p^^^^^Ps^P^^^W^^^^S^^^^^^^^^^^^^^ IWWJ^

Filters. Piping, a core feature of the original Unix system of the early 1970s, stillsurvives in modern systems because it is a simple abstraction for communicatingamongdisparate programs. Testimony to the power of this abstractionis that manyUnix programs are still being used today to process files that are thousands or millions of times largerthan imaginedbythe programs' authors. Wecan communicatewith other Java programs via calls on methods, but standard input and standardoutput allowus to communicatewith programs that werewritten at another timeand, perhaps, in another language. With standard input and standard output, weare agreeing on a simple interface to the outside world. For many common tasks,it is convenient to think of each program as afilter that converts a standard inputstream to a standard output stream in some way, with piping as the command

\


mechanism to connect programs together. For example, RangeFilter (Program1.5.4) takes two command-line arguments and prints on standard output thosenumbers from standard input that fallwithin the specifiedrange.Youmight imagine standard input to be measurement data from some instrument, with the filterbeing used to throw away data outside the range of interest for the experiment athand. Several standard filters that were designed for Unix still survive (sometimeswith different names) as commands in modern operating systems. For example,the sort filter puts the lines on standard input in sorted order:

% Java RandomSeq 6 | sort0.035813305516568916

0.14306638757584322

0.348292877655532103

0.5761644592016527

0.7234592733392126

0.9795908813988247

We discuss sorting in Section 4.2. A second useful filter is grep, which prints thelines from standard input that match a givenpattern. For example, if you type

% grep lo < RangeFilter.Java

you get the result

// Filter out numbers not between lo and hi.int lo = Integer.parselnt(args[0]);

if (t >= lo && t <= hi) StdOut.print(t + " ")",

Programmers often use tools such as grep to get a quick reminder of variablenames or language usage details.A third useful filter is more,which reads data fromstandard input and displays it in your terminal window one screenful at a time. Forexample, if you type

% Java RandomSeq 1000 | more

you will see as many numbers as fit in your terminal window, but more will waitfor you to hit the space bar before displaying each succeeding screenful. The termfilter is perhaps misleading: it was meant to describe programs like RangeFilterthat write some subsequence of standard input to standard output, but it is nowoften used to describe any program that reads from standard input and writes tostandard output.


Multiple streams. Formany common tasks, we want to writeprograms that takeinput from multiplesources and/or produceoutput intended for multipledestinations. In Section 3.1 we discuss our Out and In libraries,which generalize StdOutand Stdin to allowfor multiple input and output streams. These libraries includeprovisions not just for redirecting these streams to and from files, but also fromarbitrary web pages.

Processing large amounts of information plays an essential role in many applications of computing. A scientistmay need to analyze data collectedfrom a series ofexperiments, a stock trader maywish to analyzeinformation about recent financialtransactions, or a student may wish to maintain collections of music and movies. In these and countless other applications, data-driven programs are the norm.Standard output, standard input, redirection, and piping provides us with the capability to address such applicationswith our Java programs. We can collect datainto files on our computer through the web or any of the standard devices and useredirection and piping to connect data to our programs. Many (if not most) of theprogramming examples that we consider throughout this book have this ability.

Standard drawing Up to this point, our input/output abstractions have focused exclusively on text strings. Nowwe introduce an abstraction for producingdrawings as output. Thislibrary is easy to use and allows us to take advantage of avisual medium to cope with far more information than is possible with just text.

Aswith standard input, our standard drawing abstraction is implemented ina library that you need to download from the booksite, StdDraw. Java. Standarddrawing is very simple:we imagine an abstract drawing devicecapable of drawinglines and points on a two-dimensional canvas. The device is capable of respondingto the commands that our programs issue in the form of calls to methods in StdDraw such as the following:

public class StdDraw (basic drawing commands)

void line(double xO, double yO, double xl, double yl)

void point(double x, double y)

Like the methods for standard input and standard output, these methods are nearlyself-documenting: StdDraw.line() draws a straight line segmentconnectingthe


(w0)

1

(0,0)X *

StdDraw.line(xO, yO, xl, yl);

(i,D.. „/ point (xQy y0) with the point {xv yx) whose coor

dinates are given as arguments. StdDraw. poi nt()draws a spot centered on the point (x,y) whose coordinates are givenas arguments.The default scaleis the unit square (all coordinates between 0 and1).The standard implementation displays the canvas in a window on your computer's screen, withblack lines and points on a white background.The window includes a menu option to save yourdrawing to a file, in a format suitable for publishing on paper or on the web.

Your first drawing. The Hel 1oWorl d equivalent for graphics programming withStdDraw is to draw a triangle with a point inside. To form the triangle, we drawthree lines: one from the point (0, 0) at the lower left corner to the point (1, 0),one from that point to the third point at (1/2,V3/2), and one from that point back to (0,0).Asa final flourish, we draw a spot in the middle of the triangle. Once you have successfully downloaded StdDraw. Java and thencompiled and run Tri angl e, you are off andrunning to write your own programs thatdraw figures comprised of lines and points.This ability literally adds a new dimension tothe output that you can produce.

When you use a computer to createdrawings, you get immediate feedback (thedrawing) so that you can refine and improveyour program quickly. With a computer program, you can create drawings that you couldnot contemplate making by hand. In particular, instead of viewing our data as just numbers, we can use pictures, which are far moreexpressive. We will consider other graphicsexamples after we discuss a few other drawing commands.

class Triangle

137

public{


double t = Math.sqrt(3.0)/2.0;StdDraw.line(0.0, 0.0, 1.0, 0.0)StdDraw.line(1.0, 0.0, 0.5, t)

StdDraw.line(0.5, t, 0.0, 0.0)StdDraw.point(0.5, t/3.0);

}

-^^w^ww^^w^^^^^^ww^^

Yourfirst drawing


Control commands. The default coordinate system for standard drawing is theunit square, but we often want to draw plots at different scales. For example, atypical situation is to use coordinates in some range for the x-coordinate, or the/-coordinate, or both. Also,we often want to draw lines of different thickness andpoints of different size from the standard. To accommodate these needs, StdDrawhas the following methods:

public class StdDraw (basiccontrol commands)

void setXscale(double xO, double xl) reset x range to (x0JXj)void setYscale(double yO, double yl) resety range to (y0,yJ

void setPenRadi us (double r) set pen radius to r

Note: Methods with thesamenames butnoarguments reset todefault values.

For example, when we issue the command StdDraw. setXscal e (0, N),we are telling the drawing device that we willbe using x-coordinates between 0 and N. Notethat the two-call sequence

StdDraw.setXscale(x0, xl);StdDraw.setYscale(yO, yl);

sets the drawing coordinates to be within a bounding box whose lower left corner is at (x0, y0) andwhose upper right corner is at (xv yj. If you useinteger coordinates, Java casts them to double, asexpected. Scaling is the simplest of the transformations commonly used in graphics. In the applications that we consider in this chapter,we use it in astraightforward way to match our drawings to ourdata.

The pen is circular, so that lines have roundedends, and when you set the pen radius to r and drawa point, you get a circleof radius r. The default penradius is .002and is not affectedby coordinate scaling. This default is about 1/500the width of the default window,so that ifyou draw 200points equallyspaced along a horizontal or vertical line, you will

int N = 50;

StdDraw.setXscale(0, N);

StdDraw.setYscale(0, N);

for (int i =0; i <= N;

StdDraw.line(0, N-i,

(0,0)

i, 0);

(N,N)

Scalingto integer coordinates


mm

1

h

Program 1.5.5 Input-to-drawing filter

public class PlotFilter{

public static void main(String[] args){ // Plot points in standard input.

// Scale as per first four values.double xO = Stdin. readDoubleO;double yO = Stdin. readDoubleO;double xl = Stdin. readDoubleO ;double yl = Stdin.readDoubleO;StdDraw.setXscale(xO, xl);StdDraw.setYscale(yO, yl);

// Read and plot the rest of the points,while (!Stdin.isEmptyO){ // Read and plot a point.

double x = Stdin. readDoubleO;double y = Stdin.readDoubleO;StdDraw.point(x, y);

xO

yo

xl

yi

x, y

leftboundbottom bound

rightbound

topbound

currentpoint

Somedata is inherently visual Thefile USA. txt on thebooksite has thecoordinates of the UScities withpopulations over 500 (byconvention, the firstfour numbers are theminimum andmaximumx and y values).

™» %java pl0tF1lter <USA.txt §M*&M

if' ' • '**•'. '•/• • •.' • '•'•"'.''••'.;-.v,->li

^s^^^P^^^^^^^^^p^w^^^^^ IK^SWi^^^N^^^^^^^^^i^^^S^^^WP'^l^


be able to seeindividual circles, but if you draw 250such points, the result will looklike a line. When you issue the command StdDraw.setPenRadius(.01), you aresaying that you want the thickness of the lines and the size of the points to be fivetimes the .002 standard.

Filtering data to a standard drawing. One of the simplest applications of standard draw is to plot data, by filtering it from standard input to the drawing. PIot-Fi1ter (Program 1.5.5) is such a filter: it reads a sequence of points defined by (x,y) coordinates and draws a spot at each point. It adopts the convention that thefirst four numbers on standard input specifythe bounding box, so that it can scalethe plot without having to make an extra pass through all the points to determinethe scale (this kind of convention is typical with such data files). The graphicalrepresentation of points plotted in this way is far more expressive (and far morecompact) than the numbers themselvesor anything that we could create with thestandard output representation that our programs have been limited to until now.The plotted image that is produced by Program 1.5.5 makes it far easier for us toinfer properties of the cities (such as, for example, clustering ofpopulation centers)than does a list of the coordinates. Whenever we are processing data that representsthe physical world, a visual image is likely to be one of the most meaningful waysthat we can use to display output. PlotFilter illustrates just how easily you cancreate such an image.

Plotting a junction graph. Another important use of StdDraw is to plot experimental data or the values of a mathematical function. For example, suppose thatwe want to plot values of the function y - sin(4x) + sin(20x) in the interval [0, it] .Accomplishingthis task is a prototypical example oi sampling, there are an infinitenumber ofpoints in the interval, so wehaveto make do with evaluating the functionat a finite number of points within the interval. We sample the function by choosing a set of x-values, then computing y-values by evaluating the function at eachx-value. Plotting the function by connecting successivepoints with lines produceswhat is known as a piecewise linear approximation. The simplest way to proceed isto regularly space the x values:we decide ahead of time on a sample size,then spacethe x-coordinates by the interval sizedivided by the sample size.To make sure thatthe values we plot fall in the visible canvas,we scale the x-axis corresponding to theinterval and the y-axis corresponding to the maximum and minimum values of thefunction within the interval. The smoothness of the curve depends on properties


of the function and the size of the sample.If the sample size is too small, the renditionof the function may not be at all accurate(it might not be very smooth, and it mightmiss major fluctuations); if the sample istoo large, producing the plot may be time-consuming, since some functions are time-consuming to compute. (In Section 2.4, wewill look at a method for plotting a smoothcurve without using an excessive number ofpoints.) Youcan use this same technique toplot the function graph of any function youchoose: decide on an x-interval where youwant to plot the function, compute functionvalues evenly spaced through that intervaland store them in an array, determine andset the y-scale, and draw the line segments.

double[] x = new double[N+l];

doubled y = new double [N+l];

for (int i =0; i <= N; i++)

x[i] = Math.PI * i / N;

for (int i = 0; i <= N; i++)

y[i] = Math.sin(4*x[i]) + Math.sin(20*x[i]);

StdDraw.setXscale(0, Math.PI);

StdDraw.setYscale(-2.0, 2.0);

for (int i = 1; i <= N; i++)

StdDraw.line(x[i-l], y[i-l], x[i], y[i]);

N=20 N=200

Plotting afunction graph

Outline andfilled shapes. StdDraw also includes methods to draw circles, rectangles, and arbitrary polygons. Each shape defines an outline. When the methodname is just the shape name, that outline is traced by the drawing pen. When thename begins with f i 11ed, the named shape is instead filled solid, not traced. Asusual, we summarize the available methods in an API:

public class StdDraw (shapes)

void circle(double x, double y, double r)

void filledCircle(double x, double y, double r)

void square(double x, double y, double r)

void filledSquare(double x, double y, double r)

void polygon (doubled x, doubled y)

void filledPolygon(doubled x, doubled y)

The arguments for ci rcl e () and f i 11edCi rcl e () define a circle of radius r centered at (x,y); the arguments for square() and filledSquareO define a square


of sidelength 2r centeredon (x,y);and the arguments for pol ygon() and f i 11 ed-PolygonO define a sequence of points that we connect by lines, including one

from the last point to the first point. If you want to defineshapes other than squares or circles,use one of these methods. For example,

doubled xd = { x-r, x, x+r, x };doubled yd = { y, y+r, y, y-r };StdDraw.polygon(xd, yd);

plots a diamond (a rotated 2r-by-2r square) centered onthe point (x>y).

StdDraw.circle(x, y, r);Text and color. Occasionally, you maywishto annotate orhighlight various elements in your drawings. StdDraw hasa method for drawing text, another for setting parametersassociated with text, and another for changing the colorof the ink in the pen. We make scant use of these featuresin this book, but they can be very useful, particularly fordrawings on your computer screen.Youwill find many examples of their use on the booksite.

public class StdDraw (text and colorcommands)

void text(double x, double y, String s)

void setFont(Font f)

void setPenColor(Color c)

StdDraw.square(x,

doubled x =doubled y =StdDraw.polygon(x,

In this code, Font and Color are non-primitive types thatyou will learn about in Section 3.1. Until then, we leavethe details to StdDraw. The available pen colors are BLACK,BLUE, CYAN, DARK_GRAY, GRAY, GREEN, LIGHT_GRAY, MA

GENTA, ORANGE, PINK, RED, WHITE, and YELLOW, defined as

constants within StdDraw. For example, the call StdDraw.setPenCol or (StdDraw. GRAY) changes to gray ink. The

default ink color is BLACK. The default font in StdDraw suffices for most of the

drawings that you need (and you can find information on using other fonts on


StdDraw.square(.2, .8, .1)

StdDraw.fi11edSquare(.8, .8,StdDraw.circle(.8, .2, .2)

double[] xd = { .1, .2, .3

doubled yd = { .2, .3, .2StdDraw.fi11edPolygon(xd, yd);StdDraw.text(.2, .5, "black text")

StdDraw.setPenColor(StdDraw.WHITE)

StdDraw.text(.8, .8, "white text")

143

.2);

.2 };

.1 };

the booksite). For example, you might wish to usethese methods to annotate function plots to highlight relevant values,and you might find it usefultodevelop similar methods to annotate other parts ofyour drawings.

Shapes, color, and text are basic tools that youcan use to produce a dizzying variety of images,but you should use them sparingly. Use of such artifacts usually presents a design challenge, and ourStdDraw commands are crude by the standards ofmodern graphics libraries, so that you are likely toneed an extensive number of calls to them to produce the beautiful imagesthat you mayimagine. Onthe other hand, using color or labelsto help focusonimportant information in drawings is often worthwhile,as is using color to represent data values.

Animation. The StdDraw library supplies additional methods that provide limitless opportunitiesfor creating interesting effects.

Shape and textexamples

public class StdDraw (advanced controlcommands)

void setCanvasSize(int w, int h)

void clear()

void clear(Color c)

void show(int dt)

void show()

create canvas in screen windowofwidth from wandheight h (inpixels)

clear thecanvas towhite (default)

clear the canvas; color it c

draw, then pausedt milliseconds

draw, turn offpause mode

The default canvas size is 512-by-512 pixels; if you want to change it, call set-CanvasSi ze() before any drawing commands. The cl ear () and show() methodssupport dynamic changes in the images on the computer screen. Such effects canprovide compelling visualizations.Wegive an examplenext that also works for theprinted page. There are more examples in the booksite that are likely to captureyour imagination.


Bouncing ball. The Hel 1oWorl d of animation is to produce a black ball that appears tomove around onthe canvas. Suppose that the ball is atposition (rx, ry) andwe want to create the impression of moving it to a new position nearby, such as, forexample, (rx + .01, r + .02).We do so in two steps:

• Erase the drawing.• Draw a black ball at the new position.

To create the illusion of movement, we iterate these steps for a whole sequence ofpositions (one that will form a straight line, in this case). But these two steps donot suffice, because the computer is so quick at drawing that the image of the ballwill rapidly flicker between black and white instead of creating an animated image. Accordingly, StdDraw has a show() method that allows us to control when theresults of drawing actions are actually shown on the display. You can think of it ascollecting all of the lines,points, shapes, and text that we tell it to draw, and thenimmediatelydrawingthem allwhen weissuethe show() command. Tocontrol theapparent speed, show() takes an argument dt that tells StdDraw to wait dt milliseconds after doing the drawing. Bydefault, StdDraw issues a show() after eachline(), point(), or other drawing command; we turn that option off when wecall StdDraw. show(t) and turn it back on when we call StdDraw. show() with noarguments. With these commands, we can create the illusion of motion with thefollowing steps:

• Erase the drawing (but do not show the result).• Draw a black ball at the new position.• Show the result of both commands, and wait for a brief time.

BouncingBall (Program 1.5.6) implements these steps to create the illusion of aball moving in the 2-by-2 box centered on the origin. The current position of theball is (rx, r ),andwe compute thenew position ateach step byadding vx to rxand vyto r . Since (vx> v) is the fixeddistance that the ball moves in each time unit, it represents the velocity. Tokeep the ball in the drawing,wesimulate the effectof the ballbouncing off the walls accordingto the laws of elasticcollision. This effect is easyto implement: when the ball hits a vertical wall, we just change the velocity in thex-direction from vx to -vx, and when the ball hits a horizontal wall,we change thevelocity inthey-direction from vy to-vy. Ofcourse, you have todownload thecodefrom the booksite and run it on your computer to see motion. To make the imageclearer on the printed page, we modified BouncingBal1 to use a gray backgroundthat also shows the track of the ball as it moves (see Exercise 1.5.34).


!i

public class BouncingBall{

public static void main (Stri ng[]{ // Simulate the movement of a

StdDraw.setXscale(-1.0, 1.0);StdDraw.setYscale(-1.0, 1.0);double rx = .480, ry = .860;double vx = .015, vy = .023;double radius = .05;while(true){ // Update ball position

if (Math.abs(rx + vx) +if (Math.abs(ry + vy) +rx = rx + vx;

ry = ry + vy;

StdDraw.clear();StdDraw.fi11edCi rcle(rx, ry, radius);StdDraw.show(20);

args)bouncing ball

}}

and draw

radius >

radius >

it there.

1.0)1.0)

vx = -vx;

vy = -vy;

position

velocity

wait time

ball radius

This program simulates the movement ofa bouncing ball in the box with coordinates between-1 and +1. The ball bounces off the boundary according to the laws of elastic collision. The20-millisecond waitfor StdDraw. show() keeps the black image of the ball persistent on thescreen, even though most of the baIVs pixels alternate between black and white. Ifyou modifythis code to take the wait time dt asa command-line argument, you can control the speed ofthe ball The images below, which show the track ofthe ball, are produced bya modified versionof thiscode (seeExercise 1.5.34).

W


Standard drawing completes our programming modelby adding a "picture is wortha thousand words"component. It is a natural abstraction that you can use to betteropen up your programs to the outside world. With it, you can easilyproduce thefunction plots and visualrepresentationsof data that are commonly used in scienceand engineering.Wewill put it to such uses frequently throughout this book. Anytime that you spend now workingwith the sample programs on the last fewpageswillbe wellworth the investment.You can find many useful exampleson the book-site and in the exercises, and you are certain to find some outlet for your creativitybyusingStdDraw to meetvariouschallenges. Can you draw an AT-pointed star?Canyou make our bouncing ball actually bounce (add gravity)? You may be surprisedat how easilyyou can accomplish these and other tasks.

public class StdDraw



void text(double x, double y, String s)

void circle(double x, double y, double r)

void filledCircle(double x, double y, double r)

void square(double x, double y, double r)

void filledSquare(double x, double y, double r)

void pol ygon (doublet] x, doubled y)

void fi 11 edPol ygon (doubled x, doubled y)

void setXscale(double xO, double xl) resetxrange to (x0,x})

void setYscale(double yO, double yl) resety range to (y0,yJ

void setPenRadius(double r) setpen radius to r

void setPenColor(Color c) setpencolor to c

void setFont(Font f) set textfont to f

void setCanvasSize(int w, int h) set canvas tow-by-h window

void clear (Col or c) clearthecanvas; colorit c

voi d show(i nt dt) showall; pausedt milliseconds

void save(String filename) savetoa .jpgorw.pngfile

Note:Methods with thesame names but no arguments reset to defaultvalues.

APIfor our library ofstaticmethods for standard drawing


Asa final example of a basic abstraction for output, we consider StdAudio, a library that you can use to play, manipulate, and synthesize soundfiles. You probablyhave used your computer to process music. Nowyou can writeprograms to do so.At the same time, you will learn some conceptsbehind a venerable and important area of computer science and scientific computing: digitalsignalprocessing. We willonlyscratch the surface of this fascinating subject, but youmaybe surprised at the simplicity of the underlying concepts.

Concert A. Sound is the perception of the vibration of molecules, in particular,the vibration of our eardrums. Therefore, oscillation is the key to understandingsound. Perhaps the simplest place to start is to consider the musical note A abovemiddle C,which isknownasconcertA. This noteisnothingmorethan a sinewave,scaled to oscillate at a frequency of 440 times per second. The function sin(t) repeatsitselfonceevery 2ir unitson thex-axis, soifwe measure t in seconds and plotthe function sin(2irtX440), we get a curve that oscillates 440 times per second.Whenyou playanA byplucking a guitarstring, pushing air through a trumpet, orcausing a small cone to vibrate in a speaker, this sine wave is the prominent partof the sound that you hear and recognize as concert A. We measure frequency inhertz (cycles per second). Whenyoudouble or halve the frequency, youmove up ordown one octaveon the scale. For example, 880hertz is one octave aboveconcertA and 110 hertz is twooctaves below concert A. Forreference, the frequency rangeof human hearingis about 20to 20,000 hertz. Theamplitude (y-value) of a soundcorresponds to the volume. We plot our curves between -1 and +1 and assumethat any devices that record and playsound will scale as appropriate, with furtherscalingcontrolled by you when you turn the volumeknob.

1 4 6 9 11

ITU0 2 3 5 7 8 10 12

frequency

A 0 440.00

Atl or Bb 1 466.16

B 2 493.88

C 3 523.25

Ct» or Db 4 554.37

D 5 587.33

Dtf or Eb 6 622.25

E 7 659.26

F 8 698.46 >

FU or Cb 9 739.99

G 10 783.99

GU or Ab 11 830.61

A 12 880.00

440 x 2"

Notes, numbers, and waves

'wvvwwvy'WVVWWW^vwwwwwWWWVWXAAvwvwwwwvwwwwwwwwwwwwwwwwwwvwwWVWXAAAAAAAAAAWWWWWWWAAAWWWVWWAAAAAM

147


Other notes. A simple mathematical formula characterizes the other notes on thechromatic scale. There are twelve notes on the chromatic scale,divided equally on alogarithmic (base 2) scale.Weget the ith note abovea given note by multiplying its frequency by the(i/12)th power of 2. In other words, the frequencyof each note in the chromatic scale is precisely thefrequency of the previous note in the scale multiplied by the twelfth root of two (about 1.06). Thisinformation suffices to create music! For example,to play the tune Frere Jacques, we just need to playeach of the notes A B C#A by producing sine wavesof the appropriate frequencyfor about half a secondand then repeat the pattern. The primary method inthe StdAudio library, StdAudio. pi ay(), allowsyouto do just that.

Sampling. For digital sound, we represent a curveby sampling it at regular intervals, in precisely thesame manner as when we plot function graphs.We sample sufficiently often that we have an accurate representation of the curve—a widely usedsampling rate for digital sound is 44,100 samplesper second. For concert A, that rate corresponds toplotting each cycle of the sine wave by sampling itat about 100 points. Since we sample at regular intervals, we only need to compute the y-coordinatesof the sample points. It is that simple: we representsound asan array ofnumbers (doubl e values that arebetween -1 and +1). Our standard sound librarymethod StdAudi o. pi ay () takes an array as its argument and plays the sound represented by that array on your computer. For example, suppose thatyou want to play concert A for 10seconds.At 44,100samples per second, you need an array of 441,001doubl e values.Tofill in the array,use a for loop thatsamples the function sin(2TrtX440) at t = 0/44100,

1/40 second (various sample rates)5,512 samples/second, 137samples

11,025samples/second, 275 samples

22,050samples/'second, 551 samples

A A A A A A A A A A

VVVVv/VVVVVv

44,100 samples/second, 1,102samples

44,100 samples/second (various times)

1/40 second, 1,102 samples

1/200 second, 220 samples

111000 second

1/1000 second, 44 samples

Samplinga sine wave


1/44100, 2/44100, 3/44100, . . . 441000/44100. Once we fill the array with thesevalues, weare ready for StdAudi o. piay(), as in the following code:

int sps = 44100; // samples per secondint hz = 440; // concert Adouble duration = 10.0; // ten secondsint N = (int) (sps * duration); // total number of samplesdoubled a = new double [N+l];for (int i = 0; i <= N; i++)

a[i] = Math.sin(2*Math.PI * i * hz / sps);StdAudio.pl ay(a);

This code isthe Hel 1oWorl d ofdigital audio. Once youuse it to getyourcomputerto playthis note, you can write codeto playother notes and makemusic! The difference between creating sound andplotting an oscillating curve is nothing morethan the output device. Indeed, it is instructive and entertaining to send the samenumbers to both standard draw and standard audio (seeExercise 1.5.27).

Saving to a file. Music can take up a lot of space on your computer. At 44,100samples per second, a four-minutesongcorresponds to 4X60X44100=10,584,000numbers. Therefore, it is common to represent the numbers corresponding to asongin a binary format that uses less space than the string-of-digits representationthatweuseforstandardinput andoutput.Many such formats have beendevelopedin recent years—StdAudio uses the .wav format. You can find some informationabout the .wav format on the booksite, but you do not need to know the details,because StdAudi o takes care of the conversions foryou. Our standard library foraudio allows youto play .wav files, to write programs to create and manipulate arrays of doubl e values, and to read and write them as .wav files.

public class StdAudio

void pi ay (St ring file) play the given .wavfile

void pi ay (doubled a) play the given sound wave

void pi ay (double X) play samplefor 1/44100 second

void save (St ring file, doubled a) save to a .wav file

doubled read (St ring file) readfrom a .wavfile

APIfor ourlibrary ofstatic methodsfor standard audio

149


Illllllll^^

Si

Program 1.5.7 Digital signalprocessing

pitch

duration

hz

N

a[]

distancefromAnoteplay time

frequency

number ofsamples

sampled sinewave

public class PlayThatTune{

public static void main(String[] args){ // Read a tune from Stdin and play it.

int sps = 44100;while (!Stdin.isEmptyO){ // Read and play one note,

int pitch = Stdin.readlnt();double duration = Stdin.readDoubleO;double hz = 440 * Math.pow(2, pitch / 12.0);int N = (int) (sps * duration);doubled a = new double [N+l];for (int i = 0; i <= N; i++)

a[i] = Math.sin(2*Math.PI * i * hz / sps);StdAudio.pl ay(a);

^mmmmmmmmmmmm

}}

This is a data-driven program that plays pure tones from the notes on the chromatic scale,specified on standard input asapitch (distance from concert A) and a duration (in seconds).The test client reads the notes from standard input, creates an array by sampling a sine waveofthe specifiedfrequency and duration at44100 samples per second, and then plays each notebycalling StdAudio. pi ay().

% more elise.txt7 .25

6 .25

7 .25

6 .25

7 .25

2 .25

5 .25

3 .25

0 .50

wmmmmmmsamm

I

I

% Java PlayThatTune < elise.txt

I

toSs^^HPI^ wsmmmMmmmim^mmm


PlayThatTune (Program 1.5.7) is an examplethat shows how easilywe cancreate music with StdAudio. It takes notes from standard input, indexed on thechromaticscale from concertA,and plays them on standard audio.You can imagine all sorts of extensions on this basic scheme, some of which are addressed in theexercises. Weinclude StdAudio in our basicarsenalof programming tools becausesound processing is one important application of scientific computing that is certainly familiar to you. Not only has the commercial application of digital signalprocessing had a phenomenal impact on modern society, but the science and engineering behind it combines physics and computer science in interesting ways.We willstudy more components of digital signal processing in some detail later inthe book. (For example,you will learn in Section 2.1 how to create sounds that aremore musical than the pure sounds produced by PIayThatTune.)

I/O isa particularly convincingexample of the power of abstraction because standard input, standard output, standard draw,and standard audio can be tied to different physical devices at different times withoutmaking anychanges to programs.Although devices may differdramatically, we can write programs that can do I/Owithout depending on the properties of specific devices. From this point forward,wewill usemethodsfrom StdOut,Stdin, StdDraw, and/or StdAudi o in nearlyevery program in this book, and you willuse them in nearlyall of your programs, somakesure to downloadcopies of theselibraries. Foreconomy, wecollectively referto these libraries as Std*. One important advantage of usingsuch libraries is thatyou can switch to new devices that are faster, cheaper, or hold more data withoutchanging your program at all. In such a situation, the details of the connection area matter to be resolved betweenyour operatingsystem and the Std* implementations. On modern systems, new devices are typically supplied with software thatresolves such detailsautomaticallyfor both the operating system and for Java.

Conceptually, one of the most significant features of the standard input, standard output, standard draw, and standardaudio data streams is that they are infinite: from the point of viewof your program, thereis no limit on their length.Thispoint of view not onlyleads to programs that have a longuseful life (because theyare less sensitive to changes in technology than programs with built-in limits). Italso is related to the Turing machine, an abstract device used by theoretical computer scientists to help us understand fundamental limitations on the capabilitiesof real computers. One of the essentialproperties of the model is the idea of a finitediscretedevice that works with an unlimited amount of input and output.


Q. Whyarewenot usingthe standard Java librariesfor input, graphics,and sound?

A, We are using them, but we prefer to work with simpler abstract models. TheJava libraries behind Stdin, StdDraw, and StdAudi o are built for production programming, and the libraries and their APIs are a bit unwieldy. To get an idea ofwhat they are like,look at the codein Stdin. j ava, StdDraw.j ava, and StdAudio.Java.

Q. So, let me get this straight.If I usethe format %2. 4f for a doubl e value,I get twodigitsbeforethe decimalpoint and four digitsafter, right?

A. No, that specifies just four digits after the decimal point. The first value is thewidth of the whole field.You want to use the format %7. 2f to specifyseven characters in total, four before the decimal point, the decimal point itself, and two digitsafter the decimal point.

Q. What other conversion codes are there for pri ntf ()?

A. For integer values, there is o for octal and x for hexadecimal. There are also numerous formats for dates and times. See the booksite for more information.

Q. Can my program re-read data from standard input?

A. No.You only get one shot at it, in the samewaythat you cannot undo a pri nt-ln() command.

Q. What happens if myprogram attempts to read data from standard input after itis exhausted?

A. You will get an error. Stdin. i sEmpty () allows you to avoid such an error bychecking whether there is more input available.

Q. What does the error message Exception in thread "main" java.lang.NoClassDefFoundError: Stdin mean?

A. Youprobably forgot to put Stdin. j ava in your working directory.

Q. I have a different working directory for each project that I am working on, so I


have copies of StdOut. j ava, Stdin. j ava, StdDraw. j ava, and StdAudi o. j ava ineach of them. Is there some better way?

A. Yes. You can put them all in one directoryand usethe"classpath" mechanismtotellJava whereto find them. Thismechanism is operating-system dependent—youcan find instructions on how to use it on the booksite.

Q. Myterminal window hangs at the end of a program using StdAudi o. HowcanI avoidhavingto use <ctrl -c> to geta commandprompt?

A. Adda call to System. exi t (0) asthe lastlinein mai n(). Don't askwhy.

Q. So I use negative integers to go below concert A when making input files forPlayThatTune?

A. Right. Actually, our choice to put concert Aat 0 isarbitrary. Apopularstandard,known as the MIDI Tuning Standard, startsnumbering at the C five octaves belowconcertA.Bythat convention, concertA is 69and you do not need to use negativenumbers.

Q. Whydo I hearweird results on standard audio when I try to sonify a sinewavewith a frequency of 30,000 Hertz (or more)?

A. The Nyquist frequency, defined as one-halfthe sampling frequency, representsthe highest frequency that can be reproduced. For standard audio, the samplingfrequency is 44,100, so the Nyquistfrequency is 22,050.

153


1.5.1 Write a program that reads in integers (as many as the user enters) fromstandard input and prints out the maximum and minimum values.

1.5.2 Modify your programfrom the previous exercise to insist that the integersmust be positive (by prompting the user to enter positive integers whenever thevalue entered is not positive).

1.5.3 Write a program that takes an integer N from the command line, readsN double values from standard input, and prints their mean (average value) andstandarddeviation (square root of the sumof the squares of their differences fromthe average, divided by N-1).

1.5.4 Extend yourprogramfromtheprevious exercise to createa filter that printsall the values that are further than 1.5 standard deviations from the mean. Use an

array.

1.5.5 Writea program that reads in a sequence of integers and prints out boththe integer that appears in a longest consecutive run and the lengthof the run. Forexample, if the input is1 22151177771 1,then your programshouldprint Longest run: 4 consecutive 7s.

1.5.6 Writea filterthat readsin a sequence of integersand prints out the integers,removing repeated values that appear consecutively. For example, if the input i1221511777711111111 1, your program should print out12 15 17 1.

1.5.7 Writea program that takes a command-line argument N, reads in N-1 distinct integersbetween1 and N, and determines the missingvalue.

1.5.8 Write a program that reads in positive real numbers from standard inputand prints out theirgeometric andharmonicmeans. Thegeometric mean ofAT positive numbersxv x^ ..., xN is (xx X x^ X ... XxN)l/N. The harmonic mean is (\/xl + 1/x2 +... + l/xN) I (l/N). Hint: Forthegeometric mean, consider taking logs to avoidoverflow.

1.5.9 Suppose that the file input.txt contains the two strings F and F. What


does the following command do (see Exercise 1.2.35)?

Java Dragon < input.txt | Java Dragon | Java Dragon

public class Dragon{


String dragon = Stdin.readStringO;String nogard = Stdin. readStringO;StdOut.print(dragon + "L" + nogard);StdOut.printC ");StdOut.print(dragon + "R" + nogard);StdOut.printlnO;

}}

1.5.10 Write a filterTenPerLine that takes a sequence of integers between0 and99 and prints 10 integers per line, with columns aligned. Then write a programRandomlntSeq that takes two command-line arguments Mand Nand outputs Nrandom integers between0 and M-1. Test your programswith the command JavaRandomlntSeq 200 100 | Java TenPerLine.

1.5.11 Writea program that readsin text from standard input and prints out thenumber of words in the text. For the purposeof this exercise, a word is a sequenceof non-whitespace characters that is surroundedbywhitespace.

1.5.12 Write a program that reads in lines from standard input with each linecontaining a name and two integersand then usespri ntf() to print a table with acolumn of thenames, the integers, andthe result ofdividing the first bythe second,accurate to three decimal places. You could usea programlikethis to tabulate batting averages for baseballplayers or gradesfor students.

1.5.13 Whichof the following require saving allthevalues fromstandard input (inan array, say), and whichcouldbe implemented asa filter usingonlya fixed numberof variables? For each, the input comesfrom standard input and consistsof N realnumbers between 0 and 1.

155


• Print the maximum and minimum numbers.

• Print the /cth smallest value.

• Print the sum of the squares of the numbers.• Print the average of the N numbers.• Print the percentage of numbers greater than the average.• Print the N numbers in increasing order.• Print the N numbers in random order.

1.5.14 Write a program that prints a table of the monthly payments, remainingprincipal, and interestpaid foraloan,takingthreenumbers ascommand-line arguments:the number ofyears, the principal, andthe interestrate (see Exercise 1.2.24).

1.5.15 Write a program that takes three command-line arguments x, y, and z,reads from standard input a sequence of point coordinates (x,, ypz,),and prints thecoordinates of the point closest to (x, y, z). Recall that the square of the distancebetween (x, y, z) and (xf, y{, z{) is (x - x{)2 + (y —y{)2 + (z —z{)2. For efficiency, donot use Math.sqrt() orMath.pow().

1.5.16 Given the positions and masses of a sequenceof objects,write a programto compute their center-of-mass, or centroid. The centroid is the average positionof the N objects, weightedby mass. If the positionsand masses are givenby (xi9 yf,m|y), then the centroid (x, y, m) is given by:

m = ml + m2 +... + mNx =(mlx}+ ... + mnxN)/my =(m]yJ+ ... + mnyN)/m

1.5.17 Write a program that reads in a sequence of real numbers between -1 and+1 and printsout their average magnitude,average power, and the number of zerocrossings. The average magnitude is the average of the absolute values of the datavalues. The average poweris the average of the squares of the datavalues. The number of zero crossings is the number of times a datavalue transitions from a strictlynegativenumber to a strictly positivenumber, or vice versa. These three statisticsarewidely used to analyze digital signals.


1.5.18 Write a programthat takesacommand-line argument Nand plots an N-by-Ncheckerboard with red and black squares. Color the lower left square red.

1.5.19 Write a program that takes as command-line arguments an integer N anda double value p (between 0 and 1),plots Nequallyspaced points of size on the circumference of a circle, and then, with probability p for each pairof points, draws agrayline connecting them.

16 .125 16 .25 16 1.0

^"•v

1.5.20 Write code to draw hearts, spades, clubs, and diamonds. To draw a heart,drawadiamond, then attach two semicircles to the upperleft andupper right sides.

1.5.21 Write a programthat takes a command-line argument N and plots a rosewith N petals (if N is odd) or 2N petals (if N is even),by plotting the polarcoordinates (r, G) of the function r= sin(NO) for 8 ranging from 0 to 27r radians.

1.5.22 Write a program that takes a string s from the command line and displaysit in banner style on the screen, moving from left to right and wrapping back to thebeginning of the string as the end is reached. Add a second command-line argument to control the speed.

157


1.5.23 Modify PlayThatTune to take additional command-line arguments thatcontrol the volume (multiply each sample value by the volume) and the tempo(multiply each note's duration by the tempo).

1.5.24 Write a program that takes the name of a .wav file and a playback rate r ascommand-line arguments and plays the file at the given rate. First, use StdAudi o.read() to read the file into an array a[]. If r = 1, just play a[]; otherwise createa new array b[] of approximate size r times a. length. If r < 1, populate b[] bysampling from the original; if r > 1,populate b[] by interpolating from the original.Then play b[].

1.5.25 Write programs that uses StdDraw to create each of the following designs.

1.5.26 Write a program Ci rcl es that draws filled circles of random size at random positions in the unit square, producingimageslike those below.Your programshould take four command-line arguments: the number of circles, the probabilitythat each circle is black, the minimum radius, and the maximum radius.

200 1 .01 .01 100 1 .01 .05 500 .5 .01 .05 50 .75 .1 .2

£•-?. *^5


WB^§is0OSMtt^A

1.5.27 Visualizingaudio. ModifyPIayThatTuneto send the valuesplayedto standard drawing, so that you can watch the sound waves as they are played. Youwillhaveto experiment with plotting multiple curvesin the drawing canvasto synchronize the sound and the picture.

1.5.28 Statisticalpolling. When collectingstatisticaldata for certain political polls,it is very important to obtain an unbiased sample of registeredvoters. Assume thatyou have a file with Nregistered voters,one per line.Write a filter that prints out arandom sample of size M(see Program 1.4.1).

1.5.29 Terrain analysis. Suppose that a terrain is represented by a two-dimensionalgrid of elevationvalues(in meters).Apeak isa grid point whosefour neighboringcells (left,right, up, and down) havestrictlylowerelevation values. Writea programPeaks that reads a terrain from standard input and then computes and prints thenumber of peaks in the terrain.

1.5.30 Histogram. Suppose that the standard input stream is a sequence of doubl e values.Write a program that takes an integer N and two doubl e values / and rfrom the command line and uses StdDraw to plot a histogram of the count of thenumbers in the standard input stream that fall in eachof the N intervalsdefined bydividing (/, r) into JV equal-sized intervals.

1.5.31 Spirographs. Write a program that takes three parameters R, r, and a fromthe command line and draws the resulting spirograph. A spirograph (technically,an epicycloid) is a curve formed by rollinga circle of radius r around a larger fixedcircleof radius R. If the pen offsetfrom the centerof the rollingcircleis (r+a), thenthe equation of the resulting curve at time t is given by

x(t) = (R + r) cos (t) - (r + a) cos ((R + r)t/r)y(t) = (R + r) sin (t) - (r + a) sin ((£ +r)t/r)

Such curves were popularized by a best-selling toy that contains discs with gearteeth on the edges and smallholesthat you couldput a pen in to trace spirographs.


1.5.32 Clock. Write a program that displays an animation of the second, minute,and hour hands of an analog clock. Use the method StdDraw. show(lOOO) to update the displayroughly once per second.

1.5.33 Oscilloscope. Write a program to simulate the output of an oscilloscopeand produce Lissajous patterns. These patterns are named after the French physicist, JulesA. Lissajous,who studied the patterns that arise when two mutually perpendicular periodic disturbances occur simultaneously. Assume that the inputs aresinusoidal, so that the followingparametric equations describe the curve:

x(t)=Axsm(wxt + Qx)y(t)=Ay sin (wyt + Qy)

Take thesix parameters AXt wXf QXfAy wy> and0^ from thecommand line.

1.5.34 Bouncing ball with tracks. Modify BouncingBall to produce images likethe ones shown in the text, which show the track of the ball on a gray background.

1.5.35 Bouncing ballwithgravity. Modify BouncingBall to incorporate gravityin the vertical direction. Add calls to StdAudio. pi ay() to add one sound effectwhen the ball hits a wall and a different one when it hits the floor.

1.5.36 Random tunes. Write a program that uses StdAudi o to play random tunes.Experiment with keeping in key, assigninghigh probabilities to whole steps, repetition, and other rules to produce reasonable melodies.

1.5.37 Tile patterns. Using your solution to Exercise 1.5.25, write a programTi1ePattern that takesa command-line argument Nand draws an N-by-N pattern,using the tile of your choice. Add a second command-line argument that adds acheckerboard option. Add a third command-line argument for color selection. Using the patterns on the facing pageasa starting point, designa tile floor.Becreative!Note: These are all designs from antiquity that you can find in many ancient (andmodern) buildings.


p^^

nrrj

^^^'r^'^^'n!^^

l.

*^^'"7^

5^5

^^

7^9^

^1 4i&njSn n

^n h| lip Si IPP

•1 ^P j^^^j^l^^f^rM 31 iBjglll ^K 1111 IBflii5liG jHc Jhiiu Sliu Slilj kyl2

ry ry <-% r> <r% ^%w w w w w w

ry ry ry ry ry ryw w w w w w

/a «*% <~\ ^ ry ryw w w w w w

<*% ^% ry ry ry ryw w w w v/ w

ry ry ry ry ry ryw w w w w w

<~% <*-%. <~>, ry ry ry

161


L6 Case Study: RandomWeb Surfer

Communicating across the web has become an integral part of everyday life. Thiscommunication is enabled in part by scientific studies of the structure of the web,a subjectof active research sinceits inception.Wenext consider a simple model ofthe web that has proven to be a particularly successful approach to understanding some of its properties. Variants ofthis model are widelyused and havebeena key factor in the explosive growth ofsearch applications on the web.

The model is known as the random

surfer model, and is simple to describe.We consider the web to be a fixed set of

pages, with each page containing a fixed set of hyperlinks (for brevity,we use theterm links), and each link a reference to some other page.Westudy what happensto a person (the random surfer) who randomly movesfrom page to page,either bytyping a page name into the addressbar or by clickinga link on the current page.

The underlying mathematical model behind the web model is known as thegraph, which we will consider in detail at the end of the book (in Section 4.5).

Wedefer discussion of details about processinggraphs until then. Instead, we concentrate oncalculations associated with a natural and well-

studied probabilistic model that accurately describes the behavior of the random surfer.

The first step in studying the randomsurfer model is to formulate it more precisely. The crux of the matter is to specify what itmeans to randomly move from page to page.The following intuitive 90-10 rule capturesboth methods of moving to a new page: Assume that 90 per cent of the time the randomsurfer clicks a random link on the current page(each link chosen with equal probability) andthat 10 percent of the time the random surfergoes directly to a random page (allpages on theweb chosen withequal probability).Pages and links

1.6.1

1.6.2.

1.6.3

Computing the transition matrix . 165Simulating a random surfer 167Mixing a Markov chain 174

Programs in thissection

1.6 Case Study: Random Web Surfer

You can immediately see that this model has flaws, because you know fromyour own experience that the behaviorof a realwebsurfer is not quite so simple:

• No one chooses links or pageswith equal probability.• There is no real potential to surf directlyto each pageon the web.• The 90-10 (or any fixed) breakdown is just a guess.• It does not take the back button or bookmarks into account.

• Wecan only afford to work with a smallsample of the web.Despite these flaws, the model is sufficiently rich that computer scientists havelearned a great deal about properties of the web by studying it. To appreciate themodel, consider the small exampleon the previouspage. Which page do you thinkthe random surfer is most likely to visit?

Each person using the web behaves a bit like the random surfer, so understanding the fate of the random surfer is of intenseinterest to peoplebuilding webinfrastructure and web applications. The model is a tool for understanding the experienceof each of the hundreds of millionsof web users. In this section,you willuse the basic programming tools from this chapterto study the model and its implications.

163

more tiny.txt

•+—N

Input format We want to be able to study thebehavior of the random surfer on various web mod

els, not just one example. Consequently, we want towrite data-driven code, where we keep data in filesand write programs that read the data from standardinput. The first step in this approach is to define aninput format that we can use to structure the information in the input files. Weare freeto define anyconvenient input format.

Later in the book, you will learn how to read web pages in Java programs(Section 3.1) and to convert from names to numbers (Section 4.4) as well as othertechniques for efficient graphprocessing. Fornow, weassume that there areN webpages, numberedfrom 0 to N-1, and werepresent links with orderedpairs of suchnumbers, the first specifying the page containing the linkand the secondspecifyingthe page to which it refers. Given these conventions, a straightforward input format for the random surferproblemisan input stream consisting of an integer(thevalue of N) followed by a sequence of pairs of integers (the representations of allthe links). Stdin treats allsequences of whitespace characters as a single delimiter,so weare free to either put one link per lineor arrange them several to a line.

1 2

1 3

4 2

1 4

' links

Random surfer inputformat


Transition matrix We use a two-dimensional matrix, that we refer to as thetransition matrix, to completelyspecify the behavior of the random surfer.With Nwebpages, wedefine an N-by-Nmatrixsuch that the entry in row i and column jisthe probability that the randomsurfer moves to page j whenon page i. Our firsttaskis to writecodethat cancreate sucha matrixfor anygiven input. Bythe 90-10rule, this computation is not difficult. Wedo so in three steps:

• ReadN, and then create arrays counts [] [] and outDegree [].• Read the links and accumulate counts so that counts [i ] [j] counts thelinks from i to j and outDegree[i ] countsthe linksfrom i to anywhere.

• Usethe 90-10rule to compute the probabilities.The first two steps are elementary, and the third is not much more difficult: multiply counts [i ] [j ] by . 90/deg ree [i ] if there is a link from i to j (take a randomlink with probabiUty .9), and then add .10/N to each entry (go to a random pagewith probability .1). Transition (Program 1.6.1) performs this calculation: It is afilter that convertsthe list-of-linksrepresentation of a web model into a transition-matrix representation.

The transition matrix is significant because each row represents a discreteprobability distribution—the entries fully specify the behavior of the random surfer's next move, giving the probability of surfing to each page. Note in particularthat the entries sum to 1 (the surfer always goes somewhere).

The output of Transition defines another file format, one for matrices ofdouble values: the numbers of rows and columnsfollowed by the valuesfor matrixentries. Now,we can write programs that read and process transition matrices.

input graph

1 2

1 3

4 2

leapprobabilities

!02 .02 .02 .02 .02".02 .02 .02 .02 .02

.02 .02 .02 .02 .02

.02 .02 .02 .02 .02

.02 .02 .02 .02 .02

link counts tiegrees~0 1 0 0 0" ~1

4 0 0 2 2 1 5

0 0 0 1 0 1

10 0 0 0 1

10 1 0 0_ 2

linkprobabilities transition matrix

0 .90 0 0 0" "02 .92 .02 .02 .02"0 0 .36 .36 .18 .02 .02 .38 .38 .20

+ 0 0 0 .90 0 = .02 .02 .02 92 .02

.90 0 0 0 0 .92 .02 .02 .02 .02

.45 0 .45 0 0 .47 .02 .47 .02 .02

Transition matrix computation

1.6 Case Study: Random Web Surfer 165

Program 1.6.1 Computingthe transition matrix

public class Transition{

public static void main(String[] args){ // Print random-surfer probabilites.

int N = Stdin.readlnt();int[][] counts = new int[N][N];int[] outDegree = new int[N];while (!Stdin.isEmptyO){ // Accumulate link counts,

int i = Stdin.readlnt();int j = Stdin.readlnt();outDegree[i]++;counts[i][j]++;

}

}

StdOut.println(Nfor (int i = 0; i < N; i++){ // Print probability distribution for row i.

for (int j = 0; j < N; j++){ // Print probability for column j.

double p = .90*counts[i][j]/outDegree[i] +StdOut.printf("%8.5fM, p);

}StdOut.printlnO;

+ " " + N);

counts[i][j]

outDegree[i]

numberofpages

countof links frompagei topagej

countof links frompage i toanywhere

transition probability

.10/N;

This program is afilter that reads links from standard input and produces the correspondingtransition matrix on standard output. First, itprocesses the input to count the outlinks fromeach page. Then itapplies the 90-10 rule to compute the transition matrix (see text). Itassumesthat there are nopages that have nooutlinks in the input (see Exercise 1.6.3).

1 4

4 2

!Mki

% Java Transition < tiny.txt5 5

0.02000 0.92000 0.02000

0.02000 0.02000

0.02000 0.02000

0.92000 0.02000 0.02000 0.02000 0.020000.47000 0.02000 0.47000 0.02000 0.02000

m^mmwmd

0.02000 0.02000

0.38000 0.38000 0.20000

0.02000 0.92000 0.02000


Simulation Given thetransition matrix, simulating thebehavior of therandomsurfer involves surprisingly little code, asyou can seein RandomSurfer (Program1.6.2). This program reads a transition matrix and surfs according to the rules,starting at page 0 and taking the number of moves as acommand-line argument.It counts thenumber of times that thesurfer visits each page. Dividing thatcountby the number of moves yields anestimate of the probability thatarandom surferwindsup on the page. This probability isknown as the page's rank. In otherwords,RandomSurfer computes an estimate of all pageranks.

One random move. The keyto the computation is the random move, which isspecified by the transition matrix.We maintain a variable pagewhose value is thecurrent location of the surfer. Row page of the matrixgives, for each j, the probabilitythat the surfer next goes to j. In other words, when the surfer is at page,

our task is to generate a random inte-j 0 12 3 4 ger between 0 and N-1 according to the

probabilities p[page] [j] .47 .02 .47 .02 .02 distribution given by row page in thecumulated sum values .47 .49 .96 .98 1.0 transition matrix (the one-dimensional

.71, return 2 array PC page]). How canwe accomplish\ this task? We can use Math. random() to

"++ +H generate arandom number r between 0and 1, but how does that help us get toa random page? One way to answer this

Generating a random integer from a discrete distribution question is to think of the probabilitiesin row page as defining a set of N inter

vals in (0,1) with each probability corresponding to an interval length. Then ourrandom variable r falls intooneof theintervals, with probability precisely specifiedby the interval length. Thisreasoning leads to the following code:

double sum =0.0;for (int j = 0; j < N; j++){ // Find interval containing r.

sum += p[page][j];if (r < sum) { page = j; break; }

}

The variable sum tracks the endpoints of the intervals defined in row p[page], andthe for loop finds the interval containing the random value r. For example, suppose thatthesurfer isatpage 4inourexample. Thetransition probabilities are .47,

t /\ /t\0.0 .47 .49 .96 .98 1.0


fmm

{.3$n

hi

S

81

^iii^i

Program 1.6.2 Simulating a random surfer

public class RandomSurfer{

public static void main(String[] args){ // Simulate random-surfer leaps and links,

int T = Integer.parselnt(args[0]);int N = Stdin.readlnt();Stdin.readlnt();

// Read transition matrix.doubled [] p = new double[N] [N];for (int i = 0; i < N; i++)

for (int j = 0; j < N; j++)p[i][j] = Stdin. readDoubleO;

int page = 0; // Start at page 0.int[] freq = new int[N];for (int t = 0; t < T; t++){ // Make one random move.

double r = Math.randomO;double sum =0.0;for (int j = 0; j < N; j++){ // Find interval containing r.

sum += p[page][j];if (r < sum) { page = j; break; }

}freq[page]++;

}

for (int i =0; i < N; i++) // Print page ranks.Std0ut.printf(n%8.5fM, (double) freq[i] / T);

StdOut.printlnO;

T

N

page

p[i][j]

freq[i]

8M

number of moves

number ofpages

current page

probability that thesurfer moves frompagei topagej

number of times thesurfer hitspagei

mmmmm

This program uses a transition matrix tosimulate thebehavior ofa random surfer. It takes thenumber of moves as a command-line argument, reads thetransition matrix, performs the indicated number of moves asprescribed bythematrix, andprints therelative frequency of hittingeach page. Thekey to thecomputation is therandom move to thenextpage (see text).

mm m%Wo^w^ww**!m #1

[*•*•• ••• *"••,,•:--•:.. :>;-. :-••**•*. f,-

% Java Transition < tiny.txt | Java RandomSurfer 1000.24000 0.23000 0.16000 0.25000 0.12000



l^^^^^^^^^p^^^^^^^^^^p


.02, .47, .02, and .02, and sum takes on the values 0.0,0.47,0.49,0.96,0.98, and1.0. These values indicate that the probabilities define the five intervals (0, .47),(.47, .49), (.49, .96), (.96, .98), and (.98, 1),one for each page. Now, suppose thatMath. random () returns the value .71. We increment j from 0 to 1 to 2 and stopthere, which indicates that . 71 is in the interval (.49, .96), so we send the surfer tothe third page(page 2).Then,weperformthe samecomputation for p[2], and therandom surfer is off and surfing. For large JV, we can use binary search to substantiallyspeed up this computation (see Exercise 4.2.36). Typically, we are interestedin speeding up the search in this situation because we are likely to need a hugenumber of random moves, asyou willsee.

Markov chains. Therandom process that describes the surfer's behaviorisknownas a Markov chain, named after the Russian mathematician Andrey Markov, whodeveloped the concept in the early20th century. Markov chains are widelyapplicable, well-studied, and have many remarkable and useful properties. For example,you mayhave wonderedwhy RandomSurfer starts the random surfer at page0 whereas you might have expected a random choice. A basic limit theorem forMarkov chains says that the surfer could start anywhere, because the probabilitythat a random surfer eventuallywinds up on any particular page is the same for allstarting pages! No matter wherethe surferstarts, the processeventuallystabilizes toa point where further surfing provides no further information. This phenomenonis known as mixing. Though this phenomenon is perhaps counterintuitive at first,it explains coherent behavior in a situation that might seem chaotic. In the presentcontext, it captures the idea that the web looks pretty much the same to everyoneafter surfing for a sufficiently long time. However, not all Markov chains have thismixing property. For example, if we eliminate the random leap from our model,certain configurations of web pages can present problems for the surfer. Indeed,there existon the web sets of pages known as spider traps, which are designed toattract incoming links but have no outgoing links. Without the random leap, thesurfer could get stuck in a spider trap. The primary purpose of the 90-10 rule is toguarantee mixing and eliminate such anomalies.

Page ranks. The RandomSurfer simulation isstraightforward: it loops for the indicated number of moves, randomly surfing through the graph. Because of themixing phenomenon, increasing the number of iterations gives increasingly accurate estimates of the probability that the surfer lands on each page (the page


ranks). How do the results compare with your intuition when you first thoughtabout the question? You might have guessed that page 4 was the lowest-rankedpage, but did you think that pages 0 and 1 would rank higher than page 3? If wewant to know which page is the highest rank, we need more precision and moreaccuracy. RandomSurfer needs 10" moves to getanswers precise to ndecimalplacesand many more movesfor those answers to stabilize to an accuratevalue. For ourexample, it takes tens of thousands of iterations to get answers accurate to twodecimalplaces and millionsof iterationsto getanswers accurateto three places(seeExercise 1.6.5).The end result is that page 0 beats page 1 by 27.3% to 26.6%. Thatsuch a tiny difference would appear in such a smallproblem is quite surprising: ifyou guessed that page 0 is the most likely spot for the surfer to end up, you werelucky! Accurate page rank estimates for the web are valuable in practice for manyreasons. First, using them to put in order the pages that match the search criteriafor web searches proved to be vastly more in line with people's expectations thanprevious methods. Next, this measure of confidence and reliability led to the investment of huge amounts of money in web advertising based on page ranks. Evenin our tiny example, page ranks might be used to convinceadvertisers to pay up tofour times as much to place an ad on page 0 as on page 4. Computing page ranks is mathematically sound, an interesting computerscience problem, and big business, all rolled into one.

Visualizing thehistogram. WithStdDraw, it isalso easy to create avisual representation that can giveyou a feelingfor how the randomsurfer visit frequencies converge to the page ranks. Simplyadd

StdDraw.clear();StdDraw.setXscale(-l, N);StdDraw.setYscale(0, t); nStdDraw.setPenRadius(. 5/N) ; Pa8e mnks mth h*st°g™™for (int i =0; i < N; i++)

StdDraw.1ine(i, 0, i, freq[i]);StdDraw.show(20);

mi.

to the random move loop, run RandomSurfer for large values of T,and you will seea drawing of the frequency histogram that eventually stabilizes to the page ranks.Afteryou have used this tool once, you are likelyto find yourself using it every time


you want to study a new model (perhaps with some minor adjustments to handlelarger models).

Studying other models. RandomSu rfer andTransi ti onareexcellent examples ofdata-driven programs. You caneasily create a data modeljust by creating a file liketi ny. txt that starts with an integer Nand then specifies pairs of integersbetween0 and N-1 that represent links connecting pages. You are encouraged to run it forvarious data models as suggested in the exercises, or to make up some models ofyour own to study. If you have ever wondered how web page ranking works, thiscalculation is your chance to develop better intuition about what causes one pageto be ranked more highly than another. What kind of page is likely to be ratedhighly? One that has many links to other pages, or one that has just a few links toother pages? The exercises in this section present many opportunities to study thebehavior of the random surfer.Since RandomSurfer uses standard input, you canwrite simple programs that generate large input models, pipe their output to RandomSu rfer, and therefore study the random surfer on large models. Such flexibilityis an important reason to use standard input and standard output.

Directly simulating the behavior of a random surfer to understand the structure

of the web is appealing,but it has limitations. Think about the following question:Could you use it to compute page ranks for a web model with millions (or billions!)of web pages and links?The quick answer to this question is no,because you cannot even afford to store the transition matrix for such a large number of pages. Amatrix for millions of pages would have trillions of entries. Do you have that muchspace on your computer? Could you use RandomSurfer to find page ranks for asmaller model with, say, thousands of pages? To answer this question, you mightrun multiple simulations, record the results for a large number of trials, and theninterpret those experimental results. We do use this approach for many scientificproblems (the gambler's ruin problem is one example; Section 2.4 is devoted toanother), but it can be very time-consuming, as a huge number of trials may benecessary to get the desired accuracy. Evenfor our tiny example, we sawthat it takesmillions of iterations to get the page ranks accurate to three or four decimal places.For larger models, the required number of iterations to obtain accurate estimatesbecomes truly huge.


Mixing a Markov chain It is important to remember that the page ranks are aproperty of the web model, not any particular approach for computing it. That is,RandomSurfer is just oneway to compute page ranks. Fortunately,a simple computational model based on a well-studiedarea of mathematics provides a far moreefficientapproach than simulation to the problem of computing page ranks. Thatmodel makes use of the basic arithmetic operations on two-dimensional matricesthat we considered in Section 1.4.

Squaring a Markov chain. What is the probability that the random surfer willmove from page i to page j in two moves? The first move goes to an intermediate page k, so we calculatethe probability of moving from i to k and then from kto j for all possible k and add up the results. Forour example, the probability of moving from 1to 2 in two moves is the probability of movingfrom 1 to 0 to 2 (.02X.02), plus the probabilityof moving from 1 to 1 to 2 (.02X.38), plus theprobability of moving from 1 to 2 to 2 (.38X.02),plus the probability of moving from 1 to 3 to 2(.38X.02), plus the probability of moving from1 to 4 to 2 (.20X.47), which adds up to a grandtotal of .1172. The same process works for eachpair of pages. This calculation is one thatwe haveseen before, in the definition of matrix multiplication: the entry in row i and column j in theresult is the dot product of row i and column j inthe original. In other words, the result of multiplying p[] [] by itself is a matrix where the entryin row i and column j is the probability that therandom surfer moves from page i to page j intwo moves. Studying the entries of the two-movetransition matrix for our example is well worthyour time and will help you better understand themovement of the random surfer. For instance, the

largest entry in the square is the one in row 2 and column 0, reflecting the fact thata surfer starting on page 2 has only one link out, to page 3,where there is also onlyone link out, to page 0. Therefore, by far the most likelyoutcome for a surfer start-

171

probability ofsurfingfrom i to 2

in one move

.02 .92 .02 .02 .02

.02 .02 .38 .38 .20

.02 .02 .02 .92 .02

.92 .02 .02 .02 .02

.47 .02 .47 .02 .02

probability ofsurfingfrom 1 to i

in one move

probability ofsurfingfrom lto2

in two moves

(dotproduct)

Squaring a Markov chain


ing on page 2 is to end up in page 0 after two moves. All of the other two-moveroutes involve more choices and are less probable. It is important to note that thisis an exactcomputation (up to the limitations of Java's floating-point precision), incontrast to RandomSurfer, which produces an estimate and needs more iterationsto get a more accurate estimate.

The power method. We might then calculate the probabilities for three movesbymultiplying by p[] [] again, and for four moves by multiplying by p[] [] yet again,and so forth. However, matrix-matrix multiplication is expensive, and we areactually interested in a vector-matrix calculation. For our example, we start with thevector

[1.0 0.0 0.0 0.0 0.0 ]

which specifies that the random surferstartson page0. Multiplying this vector bythe transition matrix gives the vector

[.02 .92 .02 .02 .02 ]

which is the probabilities that the surfer winds up on each of the pages after onestep. Now, multiplying thisvector by the transition matrix givesthe vector

[.05 .04 .36 .37 .19 ]

which contains the probabilities that the surfer winds up on each of the pagesaftertwo steps. For example, the probability of moving from 0 to 2 in two moves is theprobability of moving from 0 to 0 to 2 (.02X.02), plus the probability of moving from 0 to 1 to 2 (.92X.38), plus the probability of moving from 0 to 2 to 2(.02X .02),plus the probabilityofmoving from 0 to 3to 2 (.02X .02), plus the probabilityof moving from 0 to 4 to 2 (.02X.47),which adds up to a grand total of .36. From these initial calculations, the pattern is clear: The vector givingtheprobabilities that the random surfer is at each pageafter t steps is precisely the product of thecorresponding vectorfor t —1 steps and the transition matrix. By the basic limit theorem for Markov chains, this process converges to the same vector no matter wherewe start; in other words, after a sufficient number of moves, the probability thatthe surfer ends up on any given page is independent of the starting point. Markov(Program 1.6.3) is an implementation that you can use to check convergence forour example. For instance, it gets the same results (the page ranks accurateto twodecimal places) as RandomSurfer, but with just 20 matrix-vector multiplications


rank[]

first move

[ 1.0 0.0 0.0 0.0 0.0 ] *

second move

probabilities of surfingfrom 0 to i in onemove

/ / I \ \[ .02 .92 .02 .02 .02 ]

third move

probabilities of surfingfrom 0 to i in two moves

/ / I \ \[ .05 .04 .36 .37 .19 ]

20th move

probabilities of surfingfrom 0 to i in 19 moves

/ / I \ \[ .27 .26 .15 .25 .07 ] *

p[][]

'02 .92 .02 .02 .02"

.02 .02 .38 .38 .20

,02 .02 .02 .92 .02

.92 .02 .02 .02 .02

.47 .02 .47 .02 .02

newRank[]

[ .02 .92 .02 .02 .02 ]

\ \ t / /probabilities of surfing

from 0 10 1 in one move

probabilities of surfing/ from i to2 inonemove

02 .92 .02

02 .02 .38

02 .02 .02

92 .02 .02

47 .02 .47

.02 .02

.38 .20

.92 .02

.02 .02

.02 .02

.02 .92 .02 .02 .02

.02 .02 .38 .38 .20

,02 .02 .02 .92 .02

,92 .02 .02 .02 .02

.47 .02 .47 .02 .02

.02 .92 .02 .02 .02

.02 .02 .38 .38 .20

.02 .02 .02 .92 .02

.92 .02 .02 .02 .02

.47 .02 .47 .02 .02

probability of surfingfrom 0 to 2in twomoves (dotproduct)

l= [ .05 .04 [IS].37 .19 ]

\ \ I / /probabilities of surfing

from 0 to i in two moves

[ .44 .06 .12 .36 .03 ]

\ \ 1 / /probabilities of surfing

from 0 to i in three moves

= [ .27 .26 .15 .25 .07 ]

\ \ ! / /probabilities of surfing

from 0 to i in20 moves(steadystate)

Thepowermethodfor computingpageranks (limitvalues of transition probabilities)

173


0r

m

J3™

^P

Program 1.6.3 Mixing a Markov chain

public class Markov{ // Compute page ranks after T moves.


int T = Integer.parselnt(args[0]);int N = Stdin.readlnt();Stdin.readlnt();

// Read p[][] from Stdin.doubl e[][] p = new doubl e[N] [N];for (int i =0; i < N; i++)

for (int j = 0; j < N; j++)p[i][j] = Stdin. readDoubleO;

// Use the power method to compute page ranks,double[] rank = new double[N];rank[0] = 1.0;for (int t = 0; t < T; t++){ // Compute effect of next move on page ranks,

double[] newRank = new double[N];for (int j = 0; j < N; j++){ // New rank of page j is dot product

// of old ranks and column j of p[][].for (int k = 0; k < N; k++)

newRank[j] += rank[k]*p[k][j];}

}

for (int j = 0; j < N; j++)rank[j] = newRank[j];

T

N

p[][]

rank[]

newRank[]

for (int i = 0; i < N; i++) // Print page ranks.StdOut.pri ntf("%8.5f", rank[i]);

StdOut.printlnO;

}

number ofiterations |

number ofpages

transition matrix

page ranks

newpage ranks

This program reads a transition matrix from standard input and computes the probabilitiesthat a random surfer lands on each page (page ranks) after the number of steps specified ascommand-line argument.

& • ••••••- • — • —- - •••- •• - -Yo Java Transition < tiny.txt | Java Markov 200.27245 0.26515 0.14669 0.24764 0.06806

% Java Transition < tiny.txt | Java Markov 400.27303 0.26573 0.14618 0.24723 0.06783

»^v-v

^^^^^^^^^^^^^^^^^^^s^i^^S^IW^^^^^^^^^^^^rf

;j.:S^: ^••ftlfpl


0 .002

1 .017

2 .009

3 .003

4 .006

5 .016

6 .066

7 .021

8 .017

9 .040

10 .002

11 .028

12 .006

13 .045

14 .018

15 .026

16 .023

17 .005

18 .023

19 .026

20 .004

21 .034

22 .063

23 .043

24 .011

25 .005

26 .006

27 .008

28 .037

29 .003

30 .037

31 .023

32 .018

33 .013

34 .024

35 .019

36 .003

37 .031

38 .012

39 .023

40 .017

41 .021

42 .021

43 .016

44 .023

45 .006

46 .023

47 .024

48 .019

49 .016

,l...lllll.l.llll.ll.llli..il.lllill.lillllll.llll6 22

Pageranks with histogram for a larger example

175


insteadof the tens of thousands of iterationsneeded by RandomSurfer. Another 20multiplicationsgives the resultsaccurateto three decimalplaces, as compared withmillions of iterations for RandomSurfer, and just a fewmore givethe results to fullprecision (see Exercise 1.6.6).

Markov chains are well-studied, but their impact on the web was not truly felt until 1998, when two graduate students, Sergey Brin and Lawrence Page, had the audacity to build a Markov chain and compute the probabilities that a random surferhits each page for thewhole web. Their work revolutionized web search and is thebasisfor the page ranking method usedby Google, the highlysuccessful websearchcompany that they founded. Specifically, the company periodicallyrecomputes therandom surfer's probability for each page.Then, when you do a search, it lists thepages related to your search keywords in order of these ranks. Such page ranksnow predominate because they somehow correspond to the expectations of typical web users, reliably providing them with relevant web pages for typical searches.The computation that is involved is enormously time-consuming, due to the hugenumber of pages on the web,but the result has turned out to be enormously profitable and well worth the expense. The method used in Markov is far more efficientthan simulating the behavior of a random surfer, but it is still too slow to actuallycompute the probabilities for a huge matrix corresponding to all the pages on theweb.That computation is enabled by better data structures for graphs (see Chapter4).

Lessons Developing a full understanding of the random surfer model is beyondthe scope of this book. Instead, our purpose is to show you an application that involveswriting a bit more code than the short programs that we have been using toteach specific concepts. What specificlessons can we learn from this case study?

We already have afull computational model Primitive types of dataandstrings,conditionals and loops, arrays, and standard input/output enable you to address interesting problems of all sorts. Indeed, it is a basic precept of theoretical computerscience that this model suffices to specifyany computation that can be performedon any reasonable computing device.In the next two chapters, we discuss two critical waysin which the model has been extended to drastically reduce the amount oftime and effort required to develop large and complex programs.


Data-driven code isprevalent. The concept of using standardinput and outputstreams and saving data in files is a powerful one. We write filters to convert fromone kind of input to another, generatorsthat can produce huge input files for study,and programs that can handle a wide variety of different models.We can savedatafor archiving or later use.Wecan alsoprocessdata derivedfrom some other sourceand then save it in a file, whether it is from a scientific instrument or a distantwebsite.The concept of data-driven code is an easyand flexible wayto support thissuite of activities.

Accuracy can be elusive. It is a mistake to assume that a program produces accurate answers simply because it can print numbers to many decimal places ofprecision.Often, the most difficultchallenge that we face is ensuring that we haveaccurate answers.

Uniform random numbers are only a start. When we speak informally aboutrandom behavior,we often are thinking of something more complicated than the"every value equally likely" modelthat Math. random () gives us.Manyof the problems that we consider involve workingwith random numbers from other distributions, such as RandomSurfer.

Efficiency matters. It isalso a mistake to assume thatyourcomputer issofast thatit can do any computation. Someproblemsrequire much more computational effort than others. Chapter 4 is devoted to a thorough discussion of evaluating theperformance of the programs that you write. We defer detailed consideration ofsuch issues until then, but remember that you always need to have some generalidea of the performance requirements of your programs.

Perhaps the most important lesson to learn from writing programs for complicatedproblems like the examplein this section is that debugging isdifficult. The polishedprograms in the book mask that lesson, but you can rest assured that each one isthe product of a long bout of testing,fixing bugs,and running the programs on numerous inputs. Generally we avoid describing bugs and the process of fixing themin the text because that makesfor a boring account and overlyfocuses attention onbad code, but you can find some examplesand descriptions in the exercises and onthe booksite.


1.6.1 Modify Transition to take the leap probability from the command lineand use your modified version to examine the effect on page ranks of switching toan 80-20 rule or a 95-5 rule.

1.6.2 Modify Transi ti on to ignore the effectof multiple links. That is, if thereare multiple links from one page to another, count them as one link. Create a smallexample that shows how this modification can change the order of page ranks.

1.6.3 ModifyTransi ti on to handle pageswith no outgoing links, by fillingrowscorresponding to such pageswith the value UN.

1.6.4 The code fragment in RandomSu rfer that generates the random move failsif the probabilities in the row p[page] do not add up to 1.Explainwhat happens inthat case,and suggest a wayto fix the problem.

1.6.5 Determine, to within a factor of 10, the number of iterations required byRandomSurfer to compute page ranks to four decimal places and to five decimalplaces for tiny.txt.

1.6.6. Determine the number of iterations required by Markov to compute pageranks to three decimal places, to four decimal places,and to ten decimal places fortiny.txt.

1.6.7 Download the file medi urn. txt from the booksite (which reflects the 50-page example depicted in this section) and add to it links from page 23 to everyother page.Observe the effect on the page ranks, and discussthe result.

1.6.8 Add to medi um. txt (see the previous exercise) links to page 23fromeveryother page, observe the effecton the page ranks, and discuss the result.

1.6.9 Suppose that your page is page 23 in medium. txt. Is there a link that youcould add from your page to some other page that would raise the rank of yourpage?

1.6.10 Suppose that your page is page 23 in medium. txt. Is there a link that youcould add from your page to some other page that would lower the rank of thatpage?


1.6.11 Use Transi ti on and RandomSurfer to determine the transition probabilities for the eight-page example shown below.

1.6.12 Use Transi ti on and Markov to determine the transition probabilities forthe eight-page example shown below.

Eight-page example

179


:SCreati\^lB^eB3^s

1.6.13 Matrix squaring. Write a program like Markov that computes page ranksby repeatedlysquaring the matrix, thus computing the sequence p, p2, p4, p8, p16,and so forth.Verify that allof the rows in the matrix convergeto the same values.

1.6.14 Random web. Write a generator forTransi ti on that takes as input a pagecount Nand a link count Mand prints to standard output Nfollowed by Mrandompairsof integers from 0 to N-l. (See Section 4.5 for a discussion of more realisticweb models.)

1.6.15 Hubs and authorities. Add to your generator from the previous exercise afixed number of hubsy which have links pointing to them from 10% of the pages,chosen at random, and authorities^ which havelinks pointing from them to 10%ofthe pages. Compute pageranks.Which rank higher,hubs or authorities?

1.6.16 Page ranks. Design an arrayof pagesand links where the highest-rankingpagehas fewerlinks pointing to it than some other page.

1.6.17 Hitting time. The hitting time for a pageis the expected number of movesbetween times the random surfervisits the page.Run experiments to estimate pagehitting times for ti ny. txt, comparewith page ranks, formulate ahypothesis aboutthe relationship, and test your hypothesis on medium. txt.

1.6.18 Covertime. Write a program that estimates the time required for the random surfer to visit every pageat least once, starting from a random page.

1.6.19 Graphical simulation. Create a graphical simulation where the size of thedot representingeach pageis proportional to its rank. To make your program data-driven, design a file format that includes coordinates specifying where each pageshould be drawn. Test your program on medium. txt.

^^^*^^Mi«m^^

Functions and Modulesis^iip^'^ •• mfim

§S§li|§l

Mil

2.1 Static Methods 184


2.3 Recursion 254


This chapter iscentered on a construct that has as profound an impact on control flow as do conditionals and loops: thefunction, which allows us to trans

fer control backand forth between different pieces of code. Functions (which areknown as static methods in Java) are important because they allow us to clearlyseparate tasks within a program and because they provide a general mechanismthat enables us to reuse code.

We group functions together in modules, which we cancompile independently. We usemodulesto breaka computational taskinto subtasks of a reasonable size.You will learnin this chapter howto build modules of yourown and to usethem,in a style of programming known asmodularprogramming.

Some modules aredeveloped withthe primary intentof providing code thatcan be reusedlater by manyother programs. We referto suchmodulesas libraries.In particular, weconsider in thischapter libraries forgenerating random numbers,analyzing data, and input/output for arrays. Libraries vastly extend the setof operations that we use in our programs.

We pay special attention to functions that transfer control to themselves. Thisprocess is known as recursion. At first, recursion mayseem counterintuitive, but itallows us to develop simple programs that canaddress complex tasks that wouldotherwise be much more difficult to handle.

Whenever you can clearly separate tasks within programs, you should doso. Werepeat this mantra throughout this chapter, and end the chapter with an exampleshowing how a complex programming task can be handled by breaking it intosmaller subtasks, then independently developing modules that interact with oneanother to address the subtasks.

183

Functions and Modules

2.1 Static Methods

The Java construct for implementing functions is known as the staticmethod. Themodifier static distinguishes this kind of method from the kind discussed laterin Chapter 3—we willapplyit consistently for nowand discuss the difference then.You haveactuallybeen usingstaticmeth-ods since the beginning of this book, iu Newton>s method (revisited). . . .186from printing with System, out. print- 212 Gaussian functions .195ln() to mathematical functions such as 2.1.3 Coupon collector (revisited) ... .197Math.absO and Math.sqrtO to all of 2.1.4 Play that tune (revisited) 205the methods in Stdln, StdOut, StdDraw, Programs in this sectionand StdAudio. Indeed, every Java program that you have written has a staticmethod named mai n(). In this section, you willlearn how to define and use staticmethods.

In mathematics, a function maps a value of a specified type (the domain)to another value of another specified type (the range). For example, the functionf(x) = x2 maps 2 to 4, 3 to 9, 4 to 16, and so forth. At first, we work with staticmethods that implement mathematical functions, because they are so familiar.Many standard functions are implemented in Java's Math library, but scientists andengineers work with a broad variety of mathematical functions, which cannot allbe included in the library. At the beginning of this section, you will learn how toimplement and use such functions on your own.

Later, youwill learn thatwe candomore withstatic methods than implementmathematical functions: static methods can have strings and other types as theirrange or domain, andthey canhave side effects such asproducing output. We alsoconsider in this section how to use static methods to organize programs and thusto simplify complicated programming tasks.

Static methods supporta key concept thatwill pervade yourapproach to programming from thispoint forward: Whenever you can clearly separate tasks withinprograms, you should do so. We will be overemphasizing thispoint throughout thissection and reinforcing it throughoutthisbook.Whenyouwritean essay, youbreakit up intoparagraphs; when youwrite aprogram, youwill breakit up into methods.Separating a larger task into smaller ones is much more important in programmingthan in writing, because it greatly facilitates debugging, maintenance, and reuse, which are all critical in developinggood software.

2.1 Static methods

Using and defining static methods As you know from using Java's Math library, the useof staticmethods iseasy to understand. Forexample, whenyouwriteMath. abs (a-b) in a program, the effect isasifyouwere to replace that codebythevalue that iscomputed byJava's Math. abs() methodwhen presented with the value a-b. This usage is so intuitivethat wehave hardlyneededto comment on it. Ifyou think about what the system hasto do to create this effect, you will see that itinvolves changing aprogram's controlflow. Theimplications ofbeing able to changethe controlflow in thisway isasprofound asdoing soforconditionals and loops.

Youcan define static methods other than mai n() in a . j ava file, as illustratedin Newton (Program 2.1.1). This implementation isbetter thanour original implementation of Newton's algorithm (Program 1.3.6) because it clearly separates thetwo primary tasks performedby the program: calculating the squareroot and interacting withthe user. Wheneveryou can clearly separate tasks within programs, youshould do so. The code here differs from Program _,1.3.6 in two additional respects. First, sqrt() returns Doubl e. NaN when its argument isnegative;second,mai n() tests sqrt() not just for one value, but for all the values given on the commandline. A static method must return a well-defined

value foreachpossible argument, andtaking multiple command-line arguments facilitates testingthat Newton operates as expected for various input values.

While Newton appeals to our familiaritywith mathematical functions, we will examineit in detail so that you can think carefully aboutwhat a staticmethod is and how it operates.

public class Newton{

185

cpublic static double sqrt(double c){

if (c < 0) return Double.NaN;double err = le-15;double t = c;while (Math.abs(t - c/t) > err * t)

t = (c/t + t) / 2.0;return t;

}J

1public static void main(String[] args){

int N = args.length;doubled a = new double[N];for (int i = 0; i < N; i++)

a[il = Double.parseDouble(args[i]);for (int i =0; i < N; i++){

double x =(sqrt(a[i]);)-

StdOut.println(x);

Controlflow. Newton comprises twostatic methods: sqrt() and main(). Even though sqrt()appears first in the code, the first statement executed when the program is executed is,as always,the first statement in mai n(). The next few statementsoperate asusual, except that thecode sqrt (a [i ]), which isknownasafunction call on the staticmethod sqrt (), causes a transfer ofcontrol (to the firstline ofcode in sq rt ()), each time that it is encountered. Moreover, the value of c within

Flowof controlfor a callon a staticmethod

186

Wi

m

S


public static double sqrt(double c){ // Compute the square root of c.

if (c < 0) return Double.NaN;double err = le-15;double t o c;while (Math.abs(t - c/t) > err * t)

t = (c/t + t) / 2.0;return t;

}

public static void main(String[] args){ // Print square roots of arguments.


a[i] o Double.parseDouble(args[i]);for (int i = 0; i < N; i++){ // Print square root of ith argument.

double x = sqrt(a[i]);StdOut.println(x);

}

}}


err

t

desired precision

current estimate

^f^W^^^^^i^^s^^W

N

a[]

argument count

argument 1

This program defines two static methods, one named sqrtO that computes the square rootofits argument using Newton's algorithm (see Program 1.3.6) and one named mai n(), whichtests sqrt () on command-line argument values. The constant values NaN and Infi ni ty standfor "not a number" andinfinity, respectively.

1.0

1.414213562373095

1.7320508075688772

1000.000499999875

% java Newton NaN Infinity 0 -0 -2NaN

Infinity0.0

-0.0

NaN

^ssSfSSjSESP»($SMg?s8&£P mmmmmmmmmm

i

2.1 Static methods 187

sq rt () is initialized to the value of a [i ] within mai n() at the time of the call. Thenthe statements in sqrt() are executed in sequence, as usual, until reaching a return statement, which transfers control back to the statement in main() containing the call on sq rt (). Moreover, the effectof the call is the same as if sq rt (a [0] )were a variable whose value is the value of t in sqrt () when the return t statement is executed. The end result exactlymatches our intuition: the first value assigned to xand printed isprecisely thevalue computed bycode in sqrt () (withthevalue of c initialized to a[0]). Next, the same process transfers control to sqrtagain (with the value of c initialized to a[l]), and so forth.

Function call trace. One simple approach to fol- main({l, 2})lowing the control flow through function calls is sqrt(l)....^i^rr... , Math.abs(O)to imagine that each function prints its name and return 0.0argumentwhen it is calledand its return value just return 1.0before returning, with indentation added on calls sqrM(?u u ^ n^it. Math.absCl•0)

and subtracted on returns. The result is a special return 1.0case of the process of tracing a program by print- Math •abs C1 •416666666666667)

4, , r^ . i_i f. i ti return 1.416666666666667ing the values of its variables, which we have beenusing since Section 1.2. However, the added inden- return 1.414213562373095tation exposes the flow of the control, and helps returnus check that each function has the effect that we Function call tracefor java Newton 1 2expect. Adding calls on StdOut. pri ntf() to tracea program's control flow in this way is a fine way to beginto understand what it isdoing (see Exercise 2.1.7). If the returnvalues matchour expectations, weneednottrace the function code in detail,savingus a substantialamount of work.

Anatomy ofa static method. The square root function maps a nonnegative realnumber to a nonnegative realnumber; the sqrt() static method in Newton mapsa double to a double. The firstline of a staticmethod,known as its signature, describes this information. The type of the domain is indicated in parentheses afterthe function name, along witha namecalled an argument variable that wewill useto refer to the argument. The type of the range is indicated before the functionname—we can put code that calls this function anywhere we could put an expression of that type.We willdiscuss the meaning of the pub! i c keyword in the nextsectionand the meaningof the stati c keyword in Chapter 3. (Technically, the signature in Java does not include these keywordmodifiersor the return type, but we

188

leave that distinction for experts.)Following the signature is thebody of the method, enclosedin braces. For sqrt() this codeis the same as we discussed in

Section 1.3, except that the laststatement is a return statement,

which causes a transfer of control

back to the point where the staticmethod was called. For any giveninitial value of the argument variable, the method must computea return value. The variables that

aredeclared and usedin the bodyof the methodareknownas local variables. Thereare two local variables in sq rt (): e r r and t. These variables are local to the code inthe bodyof the method and cannotbe usedoutsideof the method.

Properties of static methods For the restof this chapter, your programmingwill be centered on creating and using static methods, so it is worthwhile to consider in more detail their basic properties.

Terminology. As wehave been doing throughout, it isuseful to drawa distinctionbetween abstract concepts and Java mechanisms to implement them (the Java i fstatement implements the conditional, the whi 1e statementimplements the loop,and so forth). There are several concepts rolled up in the idea of a function, andJava constructs correspondingto each,as summarized in the following table:

signature

localvariables z

method^body


return

typemethod

name

argumenttype

argumentvariable

\^_i^public static [doubleIIsqrtl ( Idouble cl)|

if (c < 0) return Double.

;

NaN;

> err

\

* t)

Idouble err|= le-15

Idouble3= c;while

t =

(Math.abs(t - c/t)|(c/t + t) /' 2.0; >

|returnuscall on another method

return statement

Anatomy ofa static method

concept Java construct description

function static method mapping

domain argument type set of values where function is defined

range return type set ofvalues a function can return

formula method body function definition

When we use a symbolicname in a formula that definesa mathematical function(suchas/(x) = 1+x + x2), the symbolisa placeholderfor somevaluein the domain

2.1 Static methods

that will be substituted into the formula when computing the function value. InJava, the symbol that we use is the name of an argument variable. It representstheparticularvalue of interest where the function is to be evaluated.

Scope. The scope of a variable name is the set of statements that can refer to thatname. The general rule in Java is that the scopeof the variables in a block of statements is limited to the statementsin that block.In particular, the scopeofavariablein a staticmethod is limited to that method's body.Therefore, you cannot refertoa variable in one static method that is declared in another. If the method includes

smaller blocks—forexample, the body of an i f or a for statement—the scope ofanyvariables declared in one of thoseblocksis limited to just the statementswithin the block. Indeed, it is common practice to use the samevariable names in independent blocks of code. When we do so, we are declaring different independentvariables. For example,we havebeen following this practice when we use an indexi in two different for loopsin the sameprogram. A guiding principle when designing software is that eachvariable should be defined so that its scope is as small aspossible. One of the important reasons that we use staticmethods is that they easedebuggingby limiting variable scope.


public static double sqrt(double c){

if (c < 0) return Double.NaN;double err = le-15;

scope of ^ double t = c;c, err, and t while (Math.abs(t - c/t) > err * t)

t = (c/t + t) / 2.0;return t;

}



a[i] = Double.parseDouble(args[i]);scope of \

args[LN,fl/K/a[] f{or (int 1' ° 0; i <N; i++) scope ofi vdouble x = sqrt(a[i]);StdOut.println(x); ^^\ ^^

} - scope ofi andx

Scope of local and argument variables

thiscodecannot refer toargs[], N, ora[]

this code cannot refer to"^ c[],err, ort

i two differentvariables

189

190 Functions and Modules

Argument variables. You can use argument variables anywhere in the code in thebody of the function in the same wayyou use local variables. The only differencebetween an argument variable and a local variable is that the argument variable isinitialized with the argument value provided by the calling code. This approachis known aspassby value. The method works with the valueof its arguments, notthe arguments themselves. One consequence of this approach is that changing thevalue of an argument variable within a static method has no effect on the callingcode. An alternative known aspass by reference, where the method actuallyworkswith the calling code's variable, is favored in some programming environments(and actually is akin to the wayJava works for nonprimitive arguments, aswe willsee).For clarity, we do not change argumentvariables in the code in this book: ourstaticmethods take the values of argumentvariables and produce a result.

Multiple methods. You can define as manystatic methods as youwantin a . javafile. Each has a body that consists of a sequence of statements enclosed in braces.These methods areindependent, except that they may refer to each other throughcalls. They can appearin any order in the file.

Calling other static methods. Asevidenced bymai n() calling sqrt () and sqrt ()calling Math, abs() in Newton, any static method defined in a .Java file can callany other staticmethod in the same file or any static method in a Java librarysuchas Math. Also, as we see in the next section, a static method can call a static methodin any .Java file in the same directory. In Section 2.3,we consider the ramifications of the idea that a static method can even call itself.

Multiple arguments. Like amathematical function, aJava static method can takeon more than one argument,and thereforecanhavemore than one argument variable. For example,the following method computes the length of the hypotenuse ofa right triangle with sidesof length a and b:

public static double hypotenuse(double a, double b){ return Math.sqrt(a*a + b*b); }

Although the argument variables areof the same type in this case, in generaltheycan be of different types. The type and the name of each argument variable is declaredin the function signature,separated by commas.

2.1 Static methods

absolute value of ani nt value

absolute valueofadouble value

primality test

hypotenuse ofa righttriangle

Harmonic number

uniform randominteger in [0, N)

draw a triangle

public static int abs(int x){

if (x < 0) return -x;else return x;

}

public static double abs(double x)

{if (x < 0.0) return -x;else return x;

}

public static boolean isPrime(int N){

if (N < 2) return false;for (int i = 2; i <= N/i; i++)

if (N % i == 0) return false;return true;

}

public static double hypotenuse(double a, double b){ return Math.sqrt(a*a + b*b); }

public static double H(int N){

double sum = 0.0;for (int i = 1; i <= N; i++)

sum += 1.0 / i;return sum;

}

public static int uniform(int N){ return (int) (Math.random() * N); }

public static void drawTriangle(double xO, double y0,double xl, double yl,double x2, double y2 )

{StdDraw.line(xO, yO, xl, yl);StdDraw.line(xl, yl, x2, y2);StdDraw.line(x2, y2, xO, yO);

}

Typical code for implementingfunctions

191


Overloading. Static methods whose signatures differ aredifferent static methods.For example, we often want to define the same operation for values of differentnumeric types, as in the following static methods for computing absolute values:

public static int abs(int x){

if (x < 0) return -x;else return x;

}

public static double abs(double x){

if (x < 0.0) return -x;else return x;

}

These are two different methods, but sufficientlysimilar so as to justify using thesame name (abs). Using one name for two static methods whose signatures differis known as overloading, and is common in Java programming. For example, theJava Math library uses this approach to provide implementations of Math.abs(),Math.min(), and Math.max() for all primitive numeric types. Another commonuse of overloading is to define two different versions of a function, one that takesan argument and another that uses a default value of that argument.

Single return value. Like a mathematical function, a Java staticmethod can provideonlyone return value,of the typedeclaredin the method signature.This policyis not as restrictive as it might seem.First,you willseein Chapter 3 that many typesof data in Java can contain more information than a value of a single primitivetype. Second, you will see later in this section that we can use arrays as argumentsand return values for static methods.

Multiple return statements. Control goes backto the calling programassoon asthe first return statement in a static method is reached. You can put return statements wherever you need them, as in sqrt (). Even though there may be multipleretu rn statements, any static method returns a singlevalue each time it is invoked:the value following the first return statement encountered. Some programmersinsist on having only one return per function, but we are not so strict in thisbook.


Side effects. Astaticmethod mayusethekeyword void asits return type, to indicate that it has no return value.An explicit return is not necessary in a voi d staticmethod: control returns to the caller after the last statement. In this book, we usevoi d static methods for two primary purposes:

• For I/O, using Stdln, StdOut, StdDraw, and StdAudio• To manipulate the contents of arrays

You have been using voi d static methods for output since mai n() in Hel1oWorl d,and we will discuss their use with arrays later in this section.A voi d static methodis said to produce side effects (consumeinput, produceoutput, or otherwisechangethe state of the system). For example, the main() static method in our programshas a voi d return type because its purpose is to produce output. It is possible inJava to write methods that haveother side effects, but wewill avoid doing so untilChapter 3, where we do so in a specific manner supported by Java. Technically,voi d static methods do not implement mathematical functions (and neither doesMath, random() or the methods in Stdln, which take no arguments but do produce return values).

Implementing mathematical functions Why not just use the static methods that are defined within Java, such as Math.sqrt () ?The answer to this questionis that wedousesuch implementationswhentheyare present.Unfortunately, thereare an unlimited number of mathematical functions that we may wish to use andonly a small set of basic functions in the library. When you encounter a functionthat is not in the library,you need to implement a corresponding static method.

As an example, we consider the kind of code required for a familiar and important application that is of interest to many high school and college students inthe United States. In a recent year, over 1 million students took a standard collegeentrance examination. Scores range from 400 (lowest) to 1600 (highest) on themultiple-choiceparts of the test.Thesescores playa rolein making important decisions: for example, student athletes are required to have a score of at least 820, andthe minimum eligibility requirement for certain academic scholarships is 1500.What percentage of test takersare ineligible for athletics? What percentage are eligible for the scholarships?

Twofunctions from statistics enable us to compute accurate answers to thesequestions. The Gaussian (normal) distribution function is characterized by the familiar bell-shaped curve and defined by the formula 4>(x) = e~x2^2lyJ2iv. The cumulative Gaussian distribution function <$>(z) is defined to be the area under the


curve defined by <j>(x) abovethe x-axisand to the left of the vertical line x-z. Thesefunctions play an important role in science, engineering, and finance because theyarise as accurate models throughout the natural world and because they are essential in understanding experimental error.

In particular, these functions are known to accurately describe the distribution of test scores in our example, as a function of the mean (average value of thescores) and the standard deviation (square root of the sum of the squares of the

differences between each score and the mean), which arepublished each year. Given the mean |x and the standarddeviation a of the test scores, the percentage of studentswith scoreslessthan a givenvalue z is closelyapproximatedby the function <£((z - |i)/a). Static methods to calculate <J>and $ are not available in Java's Math library, so we need todevelop our own implementations.

Closed form. In the simplest situation, we have a closed-form mathematical formula defining our function in termsof functions that are implemented in the library. This situation is the case for <|>—the Java Math library includesmethods to compute the exponential and the square rootfunctions (and a constant value for it), so a static methodphi () corresponding to the mathematical definition is easyto implement (see Program 2.1.2).

No closed form. Otherwise, we may need a more complicated algorithm to compute function values. This situationis the case for <I>—no closed-form expression exists for thisfunction. Such algorithms sometimes follow immediatelyfrom Taylor seriesapproximations, but developing reliably

accurate implementations of mathematical functions is an art that needs to be addressed carefully, taking advantage of the knowledge built up in mathematics overthe past several centuries. Many different approaches have been studied for evaluating O. For example, a Taylor series approximation to the ratio of <£ and <(> turnsout to be an effective basis for evaluating the function:

*(z) = 1/2 + <(>(z) (z + z3/3 + z5/(3-5) + z7/(3-5-7) +...).

distribution <\>

area is0>{zq)

Gaussian probabilityfunctions


Program2.1.2 Gaussianfunctions

public class Gaussian{ // Implement Gaussian (normal) distribution functions

public static double phi(double x){

return Math.exp(-x*x/2) / Math.sqrt(2*Math.PI);}

public static double Phi(double z){

if (z < -8.0) return 0.0;if (z > 8.0) return 1.0;double sum = 0.0, term = z;for (int i = 3; sum != sum + term; i += 2){

sum = sum + term;

term = term * z * z / i;

}return 0.5 + phi(z) * sum;

}


double z = Double.parseDouble(args[0]);double mu = Double.parseDouble(args[1]);double sigma = Double.parseDouble(args[2]);Std0ut.printf("%.3f\n", Phi((z - mu) / sigma));

}

cumulated sum

current term

This code implements theGaussian (normal) density (phi) andcumulative distribution (Phi)functions, which arenot implemented in Java's Math library. The phi () implementation followsdirectly from its definition, and the Phi () implementation uses a Taylor series and alsocallsphi () (seeaccompanying textat leftand Exercise 1.3.36).

%Mi% Java Gaussian 820 1019 2090.171

% Java Gaussian 1500 1019 2090.989

% Java Gaussian 1500 1025 2310.980


This formula readily translates to the Java code for the static method Phi () in Program2.1.2. For small (respectively large)z, the value is extremelycloseto 0 (respectively1), so the code directly returns 0 (respectively 1); otherwise, it uses the Taylorseries to add terms until the sum converges.

Running Gaussian with the appropriate arguments on the command linetells us that about 17% of the test takers were ineligible for athletics and that onlyabout 1% qualified for the scholarship.In a year when the mean was 1025 and thestandard deviation 231,about 2% qualifiedfor the scholarship.

Computing with mathematical functions of all sorts has always played a centralrole in science and engineering. In a great many applications, the functions thatyou need are expressed in terms of the functions in Java's Math library as we havejust seen with phi (), or in terms of Taylor series approximations that are easy tocompute, as we have just seen with Phi (). Indeed, support for such computationshas played a central role throughout the evolution of computing systems and programming languages. You will find many exampleson the booksite and throughoutthis book.

Using static methods to organize code Beyond evaluating mathematicalfunctions, the process of calculating a result value on the basis of an input value isimportant as a general technique for organizing control flow in any computation.Doing so is a simple example of an extremely important principle that is a primeguiding force for any good programmer: Whenever you can clearly separate taskswithin programs, you should doso.

Functions are natural and universal for expressing computational tasks. Indeed, the "bird's-eye view"of a Javaprogram that we began with in Section 1.1wasequivalent to a function: we began by thinking of a Javaprogram as a function thattransforms command-line arguments into an output string. This view expressesitself at many different levelsof computation. In particular, it is generally the casethat a long program is more naturally expressed in terms of functions instead of asa sequence of Javaassignment, conditional, and loop statements. With the ability todefine functions, we can better organize our programs by defining functions withinthem when appropriate.

For example, Coupon (Program 2.1.3) is a version of CouponCol1ector (Program 1.4.2) that better separates the individual components of the computation. Ifyou study Program 1.4.2,you will identify three separate tasks:


KSProgram 2,1.3 Coupon collector (revisited)

1

public class Coupon{

public static int uniform(int N){ // Generate a random integer between 0 and N-1.

return (int) (Math.random() * N);

}

public static int collect(int N){ // Collect coupons until getting one of each value.

boolean[] found = new boolean[N];int cardcnt = 0, valcnt = 0;while (valcnt < N) found[]

{int val = uniform(N);cardcnt++;if (!found[val]) valcnt++;found[val] = true;

cardcnt

valcnt

val

cumulated sum

number collected

number thatdiffer

current value

}return cardcnt;

}

public static void main(String[] args){ // Print the number of coupons collected

// to get N different coupons.int N = Integer.parselnt(args[0]);int count = collect(N);StdOut.pri ntln(count) ;

}

-mmmmmmmmm

This version ofProgram 1.4.2illustrates the style ofencapsulating computations instatic methods. This code has the sameeffect as CouponCol lector, but better separates the code into itsthree constituent pieces: generating a random integer between 0 andN-1, running a collectionexperiment, and managing theI/O.

% Java Coupon 10006522

% Java Coupon 10006481

% Java Coupon 100000012783771

*mmumuMm&MmmMm

I


• Given N, compute a random coupon value.• GivenN, do the coupon collection experiment.• GetN from the command line,then compute and print the result.

Coupon rearranges the codein CouponCol 1ect to reflect the reality that these threefunctions underlie the computation.

With this organization, we couldchange uniform() (for example, we mightwant to draw the random numbers from a different distribution) or main() (forexample, wemight want to takemultipleinputs or run multiple experiments)without worrying about the effect of any changes on col 1ect ().

Using static methods isolates the implementation of eachcomponent of thecollection experiment from others, or encapsulates them. Typically, programs havemany independent components,which magnifies the benefits of separating theminto different static methods. We will discuss these benefits in further detail after we

have seen several other examples, but you certainlycan appreciate that it is betterto express a computation in a programby breaking it up into functions, just as itisbetter to express an ideain an essay by breaking it up into paragraphs. Wheneveryou can clearly separate tasks within programs, youshould do so.

ImplemeBtiiug static methods for arrays A static method cantake an arrayasan argument or asa return value. This capability is a special case of Java's objectorientation,which is the subjectof Chapter3.We considerit in the presentcontextbecause the basicmechanismsare easy to understandand to use,leading us to compact solutions to a number of problems that naturallyarise when we use arrays tohelp us process large amounts of data.

Arrays as arguments. When a static method takes an array as an argument, itimplements a function that operates on an arbitrary number ofvaluesof the sametype. For example,the following static method computes the mean (average) valueof an arrayof doubl e values.

public static double mean (doubled a){

double sum =0.0;for (int i = 0; i < a.length; i++)

sum = sum + a[i];return sum / a.length;

}


Wehavebeen using arrays as arguments from the beginning.The code


defines main() as a static method that takes an array of strings as an argumentand returns nothing. Byconvention, the Java system collects the strings that youtype after the program name in the Java command into an array args [] and callsmain() with that array as argument. (Most programmers use the name args forthe argument variable, even though any name at all would do.) Within mai n(), wecan manipulate that array just like any other array. The mai n() method in Newton(Program 2.1.1) is an example of such code.

Side effects with arrays. It is often the case that the purpose of a static methodthat takes an array as argument is to produce a side effect (changevalues of arrayelements). A prototypical example of such a method is one that exchangesthe values at two given indices in a given array.We can adapt the code that we examinedat the beginning of Section 1.4:

public static void exch(String[] a, int i, int j){

String t = a[i] ;a[i] = a[j];a[j] = t;

}

This implementation stems naturally from the Java array representation. The argument variable in exch () is a reference to the array, not to all of the array's values:when you pass an array as argument to a static method, you are giving it the opportunity to operate on that array (not a copyof it).Asecondprototypical exampleof a static method that takes an array argument and produces side effects is onethat randomly shuffles the values in the array, using this version of the algorithmthat we examined in Section 1.4 (and the exch() and uniformO methods justdefined):

public static void shuffle(String[] a){

int N = a.length;for (int i =0; i < N; i++)

exch(a, i, i + uniform(N-i));}

200

find themaximumof thearray values

dotproduct

exchange two elementsin an array

print a ID array(and its length)

reada 2D arrayof double values(with dimensions)in row-major order


public static double max (doubled a){

double max = Double.NEGATIVE_INFINITY;for (int i = 0; i < a.length; i++)

if (a[i] > max) max = a[i];return max;

}

public static double dot(double[] a, doubled b){

double sum = 0.0;for (int i = 0; i < a.length; i++)

sum += a[i] * b[i];return sum;

}

public static void exch(String[] a, int i, int j){

String t = a[i];a[i] = a[j];a[j] = t;

}

public static void print(doubled a){

StdOut.pri ntln(a.1ength);for (int i =0; i < a.length; i++)

StdOut.println(a[i]);}

public static doubled [] readDouble2D(){

int M = Stdln.readlntO;int N = Stdln. readlntO;doubled [] a = new double[M] [N] ;for (int i = 0; i < M; i++)

for (int j = 0; j < N; j++)a[i][j] = Stdln. readDoubleO;

return a;

}

Typical codefor implementingfunctions witharrays


Similarly, we will consider in Section 4.2 methods that sort an array (rearrangeits values so that they are in order). All of these examples highlight the basic factthat the mechanism for passingarraysin Java is a call-by-reference mechanismwithrespect to the contents of the array. Unlike primitive-type arguments, the changesthat a method makes in the contents of an array arereflected in the client program.A method that takes an array as argument cannot change the array itself—the reference is the same memory location assignedwhen the array was created, and thelength is the value set when the array was created—but it can change the contentsof the array to any values whatsoever.

Arrays as return values. A method that sorts, shuffles, or otherwise modifies anarray taken as argument does not have to return a referenceto that array,because itis changing the contents of a client array, not a copy. But there are many situationswhere it is useful for a static method to provide an array as a return value. Chiefamong these are static methods that create arrays for the purpose of returning multiple values of the same type to a client. For example, the following static methodproduces an array of the kind used by StdAudio (see Program 1.5.7) that containsvalues sampled from a sine wave of a given frequency (in hertz) and duration (inseconds), sampled at the standard 44,100 samples per second.

public static doubled tone(double hz, double t){

int sps = 44100;int N = (int) (sps * t);doubled a = new double[N+l];for (int i = 0; i <= N; i++)

a[i] = Math.sin(2 * Math.PI * i * hz / sps);return a;

}

In this code, the size of the array returned depends on the duration: if the givenduration is t, the size of the array is about 44100*t. With static methods like thisone, we can write code that treats a sound waveas a single entity (an array containing sampled values), as we will see next in Program 2.1.4.


Examples superposition of soumd waves As discussed in Section 1.5, thesimple audio model that we studied there needs to be embellished in order to createsound that resembles the sound producedby a musicalinstrument. Manydifferentembellishments are possible;with static methods we can systematicallyapply themto produce sound waves that are far more complicated than the simple sine wavesthat we produced in Section 1.5. As an illustration of the effective use of staticmethods to solve an interesting computational problem, we consider a programthat has essentiallythe same functionality as PlayThatTune (Program 1.5.7),butadds harmonic tones one octave above and one octave below each note in order to

produce a more realistic sound.

Chords and harmonics. Notes like concert A have a pure sound that is not verymusical, because the sounds that you are accustomed to hearing have many othercomponents. The sound from the guitarstring echoes off the wooden part of theinstrument, the walls of the room thatyou are in, and so forth. You may thinkof such effects as modifying the basicsine wave. For example, most musicalinstruments produce harmonics (thesame note in different octaves and not

as loud), or you might play chords (multiple notes at the same time). To combinemultiple sounds, we use superposition:simply add their waves together and res-cale to make sure that all values stay between —1 and +1. As it turns out, when

we superpose sine waves of differentfrequencies in this way, we can get arbitrarilycomplicatedwaves. Indeed, one of the triumphs of 19th century mathematics wasthe development of the idea that any smooth periodic function can be expressedasa sum of sine and cosine waves, known as a Fourier series. This mathematical ideacorresponds to the notion that we can create a large range of sounds with musicalinstruments or our vocal chords and that all sound consists of a composition ofvarious oscillating curves. Any sound corresponds to a curve and any curve corresponds to a sound, and we can create arbitrarily complex curves with superposition.

A majorchord

concert A with harmonics

440.00

554.37

659.26

440.00

220.00

880.00

Superposing waves to make composite sounds

2.1 Static methods

Superposition. Since we represent sound waves by arrays of numbers that represent their values at the same sample points, superposition is simple to implement:we add together their sample values at each sample point to produce the combinedresult and then rescale. For greater control, we specify a relative weight for each ofthe two waves to be added, with the property that the weightsare positiveand sumto 1. For example, if we want the first sound to have three times the effect of thesecond, we would assign the first a weight of .75 and the second a weight of .25.Now,if one waveis in an array a [] with relative weight awt and the other is in anarray b[] with relative weight bwt, we compute their weighted sum with the following code:

doubled c = new double [a. length];for (int i = 0; i < a.length; i++)

c[i] = a[i]*awt + b[i]*bwt;

The conditions that the weights are positive and sum to 1 ensure that this operation preserves our convention of keeping the values of all of our wavesbetween —1and+1.

.982

-.693

.144

.374

.259

lo = tone(220, .0041);lo[44] = .982

hi = tone(880, .0041);hi[44] = -.693

h = sum(hi, lo, .5, .5);h[44] = .5*lo[44]+.5*hi[44];

= .5*.982 - .5*.693 = .144

A = tone(440, .0041);A[44] = .374

sum(A, h, .5, .5);A[44] + h[44] = .5*. 144 + .5*. 374

= .259

Addingharmonics to concert A (180 samples at 44,100 samples/sec)

203


Program 2.1.4 is an implementation that applies these concepts to produce a morerealisticsound than that produced by Program 1.5.7. In order to do so,it makesuseof functions to divide the computation into four parts:

• Given a frequency and duration, create apure tone. . J

• Given two sound waves and

relative weight, superposethem.

• Given a pitch and duration,create a note with harmonics.

• Read and play a sequence ofpitch/duration pairs fromstandard input.

These tasks are each amenable

to implementation as functions,which depend on one another.Each function is well-defined and

straightforward to implement. Allof them (and StdAudio) representsound as a series of discrete values

kept in an array, corresponding tosampling a sound wave at 44,100samples per second.

Up to this point, the use offunctions has been somewhat of a

notational convenience. For exam

ple, the control flow in Programs2.1.1-2.1.3 is simple—each function is called in just one place inthe code. By contrast, PlayThat-TuneDeluxe (Program 2.1.4) is aconvincing example of the effectivenessofdefining functions to organize a computation because the functions are each called multiple times. For example, the function note() calls the function tone() three times and the functionsum() twice.Without static methods, wewould need multiple copiesof the code in

y

public class PlayThatTune

{ (rpublic static double[] sum(double[] a, doubled b,

double awt, double bwt){

doublet] c = new double[a.length];for (int i o 0; i < a.length; i++)

c[i] = a[i]*awt + b[i]*bwt;return c;

fcr„public static doublet] tone(double hz, double t){

int sps » 44100;int N - (int) (sps * t);doubled a = new double[N+l];for (int i = 0; i <= N; i++)

a[i] - Math.sin(2 * Math.PI * i * hz / sps);return a;

}

M.public static double[] note(int pitch, double t){

double hz =. 440.0 * Math.pow(2. pitch / 12.0);double[] a °(tone(hz, t);)

doubl e[] hi °(tone(2*hz, t);>-

double[] lo »(tone(hz/2r"t)p-

double[] h -(sum(hi, lo, .5, .5);>-

return(sum(a, h, .5, .5);^)-

J


while (!Stdln.isEmpty()){

int pitch = Stdln.readlntO;double duration ° Stdln.readDoubleQ;double[] a °(note(pitch, duration)Q -

StdAudio.piay(a);

^

Flowof control amongseveral staticmethods


1

?3S

SI

•fetft?

Hi

P

* ,-:..J

Program 2.1.4 Play that Tune (revisited)

public class PlayThatTuneDeluxe{

public static doubled sum(double[] a, doubled b,double awt, double bwt)

{ // Superpose a and b, weighted.doubled c = new double[a.length];for (int i = 0; i < a.length; i++)

c[i] = a[i]*awt + b[i]*bwt;return c;

}

public static doubled tone (double hz, double t)// see text

public static doubled note (int pitch, double t){ // Play note of given pitch, with harmonics.

double hz = 440.0 * Math.pow(2, pitch / 12.0);doubled a = tone(hz, t);doubled hi = tone(2*hz, t);doubled lo = tone(hz/2, t);doubled h = sum(hi, lo, .5, .5);return sum(a, h, .5, .5);

}

public static void main(String[] args){ // Read and play a tune, with harmonics.

while (!Stdln.isEmptyO){ // Read and play a note, with harmonics.

int pitch = Stdln.readlntO;double duration = Stdln.readDouble();doubled a = note(pitch, duration);StdAudio.pl ay(a);

}}

hz

a[]

hi[]

lo[]

h[]

m

frequencypure tone

upper harmonic

lower harmonic

tone with harmonics

This code embellishes thesounds produced byProgram 1.5.7byusing static methods to createharmonics, which results in a more realistic sound than the puretone.

% more el i se .txt

7 .25

6 .25

7 .25

6 .25

7 .25

% Java PlayThatTuneDeluxe < elise.txt

^mammummm


tone() and sum(); with static methods, we can deal directly with concepts closeto the application. As with loops, methods have a simple but profound effect: wehave one sequence of statements (those in the method definition) executed multiple times during the execution of our program—once for each time the methodis called in the control flow in mai n().

Static methods are important because they give us the ability to extend the Javalanguage within a program. Having implemented and debugged static methodssuch as sqrt(), phi(), Phi(), mean(), abs(), exch(), shuffle(), isPrimeO,H(), uniformO, sum(), note(), and tone(), we can use them almost as if theywere built into Java. The flexibility to do so opens up a whole new world of programming. Before, you weresafein thinking about a Java program as a sequenceofstatements. Now you need to think of a Javaprogram as a setofstaticmethods thatcan call one another. The statement-to-statement control flow to which you havebeen accustomed is stillpresent within static methods, but programs have a higher-level control flow defined by static method calls and returns. This ability enablesyou to think in terms of operations calledfor by the application, not just the simplearithmetic operations on primitive types that are built in to Java.

Whenever you canclearly separate tasks within programs, youshould doso. Theexamplesin this section (and the programs throughout the rest of the book) clearlyillustrate the benefits of adhering to this maxim. With static methods, we can

• Divide a long sequence of statements into independent parts.• Reusecode without having to copy it.• Work with higher-level concepts (such as sound waves).

This produces code that is easier to understand, maintain, and debug than a longprogram composed solelyof Javaassignment, conditional, and loop statements. Inthe next section, we discuss the idea of using static methods defined in other programs, which again takes us to another levelof programming.

2. / Static methods

Q. Whydo I need to use the return type voi d? Whynot just omit the return type?

A. Java requires it; we have to include it. Second-guessing a decision made by aprogramming-language designer is the first step on the road to becoming one.

Q. Can I return from a void function by using return? If so, what return valueshould I use?

A. Yes. Use the statement return; with no return value.

Q. What happens if I leave out the keyword stati c?

A. As usual, the best wayto answer a question like this is to try it yourselfand seewhat happens. Here is the result of omitting stati c for sq rt () in Newton:

Newton.Java:13: non-static method sqrt(double)cannot be referenced from a static context

double x = sqrt(i);A

1 error

Non-static methods are different from static methods. You will learn about the

former in Chapter 3.

Q. What happens if I write code after a return statement?

A. Once a return statement is reached, control immediately returns to the caller,so any code after a return statement is useless. The Java compiler identifies thissituation as an error, reporting unreachabl e code .

Q. What happens if I do not include a return statement?

A. No problem, if the return type is void. In this case, control will return to thecaller after the last statement. When the return type is not voi d, the compiler willreport a mi ssi ng retu rn statement error if there is any path through the codethat does not end in a return.

Q. This issuewith side effects and arrayspassedas arguments is confusing. Is it really all that important?

207


A. Yes. Properly controlling side effects is one of a programmer's most importanttasks in large systems. Taking the time to be surethat you understand the differencebetween passing a value (when arguments are of a primitive type) and passing areference (whenargumentsare arrays) willcertainlybe worthwhile. The verysamemechanism is used for all other types of data, as you will learn in Chapter 3.

Q. Sowhynot just eliminatethe possibility of side effects by making all argumentspass-by-value, including arrays?

A. Think of a huge array with, say, millions of elements. Does it make sense tocopy all of those values for a static method that is just going to exchange two ofthem? For this reason, most programming languagessupport passing an array to afunction without creatinga copyof the arrayelements—Matlabis a notable exception.

2.7 Static methods

2.1.1 Write a static method max3 () that takesthree i nt values as arguments andreturns the value of the largestone.Add an overloadedfunction that does the samething with three doubl e values.

2.1.2 Write a static method odd() that takes three boolean inputs and returnstrue if an odd number of inputs are true, and fal se otherwise.

2.1.3 Writea staticmethod majori ty () that takes three boolean argumentsandreturns true if at least two of the arguments havethe value true, and fal se otherwise. Do not use an i f statement.

2.1.4 Write a static method eq() that takes two arrays of integers as argumentsand returns true if theycontain the samenumber of elements and allcorresponding pairs of elements are equal.

2.1.5 Write a static method areTri angul ar () that takes three doubl e values asarguments and returns true if they could be the sidesof a triangle (none of themis greater than or equal to the sum of the other two). SeeExercise 1.2.15.

2.1.6 Write a static method si gmoi d() that takesa double argument x and returns the doubl e value obtained from the formula 1/(1—e~x).

2.1.7 If the argument of sqrt () in Newton (Program 2.1.1) has the value Infin-i ty, then Newton. sq rt () returns the value Infi ni ty, as desired. Explainwhy.

2.1.8 Add a method abs() to Newton (Program 2.1.1), change sqrt() to useabs () instead of Math.abs (), and add print statements to produce a function calltrace, as describedin the text.Hint: You need to add an argument to each functionto give the level of indentation.

2.1.9 Give the function call trace for Java Newton 4.0 9.0.

2.1.10 Write a static method lg() that takes a double value Nas argument andreturns the base 2 logarithm of N. You may use Java's Math library.

2.1.11 Write a static method lg() that takes an int value Nas argument and returns the largest i nt not larger than the base-2 logarithm of N. Do not use Math.

209


2.1.12 Write a static method si gnum() that takes an i nt value Nas argument andreturns -1 if Nis less than 0,0 if Nis equal to 0, and +1 if Nis greater than 0.

2.1.13 Consider the static method dupl i cate () below.

public static String duplicate(String s){

String t = s + s;return t;

}

What does the following code fragment do?

String s = "Hello";s = duplicate(s);String t = "Bye";t = duplicate(duplicate(duplicate(t)));StdOut.println(s + t);

2.1.14 Consider the static method cube() below.

public static void cube(int i){

i = i * i * i;

}

How many times is the followingfor loop iterated?

for (int i = 0; i < 1000; i++)cube(i);

Answer: Just 1,000 times. A call to cube() has no effect on client code. It changesthe value of its local argument variable i, but that change has no effect on the i inthe for loop, which is a different variable. If you replace the call to cube(i) withthe statement i = i * i * i; (maybe that was what you were thinking), thenthe loop is iterated five times, with i taking on the values 0,1, 2, 9, and 730 at thebeginning of the five iterations.

2.1.15 The following checksum formula is widely used by banks and credit card

2.1 Static methods

companies to validate legalaccount numbers:d0 +M) + d2 +f(d3) + d4 +f(d5) + ... =0 (mod 10)

The dx are the decimal digits of the account number and f(d) is the sum of thedecimal digits of 2d (for example,/(7) = 5 because 2X7 = 14 and 1+ 4 = 5). Forexample 17327 is valid because 1+5+3+4+7=20, which is a multiple of 10.Implement the function/and write a program to takea 10-digit integeras a command-line argument and print a valid 11-digit number with the given integer as its first10digits and the checksum as the last digit.

2.1.16 Given twostarswith angles of declination and rightascension (dvax) and(d2> a2), the angle they subtend is given by the formula

2 arcsin((sin2(d/2) + cos (d1)cos(d2)sin2(a/2))1/2),

where ax and a2 areangles between -180 and 180 degrees, dx and d2 areangles between -90 and 90degrees, a = a2- avandd= d2- dvWrite a programto takethedeclination and right ascension of twostars ascommand-line arguments and printthe angle theysubtend.Hint: Be careful about converting from degrees to radians.

2.1.17 Write a readBoolean2D() method that reads a two-dimensional booleanmatrix (with dimensions) into an array.

Solution: The body of the method is virtually the same as for the correspondingmethod given in the table in the text for 2Darrays of double values:

public static boolean[][] readBoolean2D(){

int M = Stdln.readlntO;int N = Stdln.readlntO;boolean[][] a = new boolean[M][N];for (int i = 0; i < M; i++)

for (int j = 0; j < N; j++)a[i][j] = Stdln.readBoolean();

return a;

}

Note that Stdln accepts0 and 1 as boolean values in the input stream.

2.1.18 Write a method that takes an array of double values as argument and re-

211


scales the arrayso that each element is between 0 and 1 (by subtracting the minimum value from each element and then dividing each element by the differencebetween the minimum and maximum values). Use the max() method defined inthe table in the text, and write and use a matching min() method.

2.1.19 Write a method hi stogramO that takes an arraya[] of i nt values and anintegerMasargument and returnsan array of length Mwhose i th entry is the number of times the integer i appeared in the argument array. If the values in a[] areallbetween 0 and M-l, the sum of the values in the returned arrayshould be equalto a.length.

2.1.20 Assemble code fragments in this section and in Section 1.4 to develop aprogram that takes JV from the command line and prints N five-card hands, separated by blank lines, drawn from a randomlyshuffledcard deck, one card per lineusing cardnames like Ace of Clubs.

2.1.21 Write a method mul ti pi y0 that takes two square matrices of the samedimensionasarguments andproduces theirproduct(another square matrix ofthatsamedimension). Extra credit: Make your program work whenever the number ofrows in the first matrix is equal to the number of columns in the second matrix.

2.1.22 Write a method any() that takes an arrayof bool ean values as argumentand returns true if any of the entries in the array is true, and fal se otherwise.Write a method al 1() that takes an array of bool ean values as argument and returns true if allof the entries in the arrayaretrue, and fal se otherwise.

2.1.23 Develop a version of getCouponO that better models the situation whenone of the coupons is rare: choose one value at random, return that value withprobability N/1000, and return allothervalues with equalprobability. Extra credit:How does this change affect the average value of the coupon collector function?

2.1.24 Modify PI ayThatTune to addharmonics two octaves awayfrom eachnote,with half the weight of the one-octave harmonics.

2.1 Static methods

2.1.25 Birthday problem. Develop a class with appropriate static methods forstudying the birthday problem (seeExercise 1.4.35).

2.1.26 Euler's totient function. Euler's totient function is an important functionin number theory: cp(n) is defined as the number of positive integers less than orequal to n that are relatively prime with n (no factors in common with n other than1). Write a class witha function that takes an integer argument nandreturns <p(n),and a mai n() that takes an integer fromthe command line, calls the function, andprints the result.

2.1.27 Harmonic numbers. Write a program Harmonic that contains three staticmethods H(), Hsmall (), and HlargeO for computing the Harmonic numbers.The Hsmall () method should just compute the sum (as in Program 1.3.5), theHlargeO method should use the approximation HN = log^N) + 7 + 1/(2N) -1/(12N2) + 1/(120N4) (the number 7 = .577215664901532... is known as Euler'sconstant), and the H() method should call Hsmall () for N < 100 and HlargeOotherwise.

2.1.28 Gaussian random values. Experiment with the following method for generating random variables from theGaussian distribution, which isbased on generatinga randompoint in the unit circle and using a formof the Box-Muller formula(see Exercise 1.2.27 and the discussion of do-whi 1e at the end of Section 1.3).

public static double gaussian(){

double r, x, y;do

{x = uniform(-1.0, 1.0);y = uniform(-1.0, 1.0);r = x*x + y*y;

} while (r >= 1 j| r == 0);

}return x * Math.sqrt(-2 * Math.log(r) / r);

Take a command-line argument Nandgenerate Nrandom numbers, using an arraya [20] to count the numbers generated that fallbetween i *. 05 and (i +1)*. 05 for

213


i from 0 to 19. Then use StdDraw to plot the values and to compare your resultwith the normal bell curve.

2.1.29 Binary search. A general method that we study in detail in Section4.2 iseffective forcomputing theinverse ofacumulative probability density function likePhi (). Such functions are continuous and nondecreasing from (0,0) to (1,1). Tofind thevalue x0 for whichf(x0) =yQy check thevalue of/(.5). Ifit isgreater thany0,then x0 must bebetween 0and .5; otherwise, itmust bebetween .5 and1. Either way,wehalve the lengthof the interval knownto containx0. Iterating, wecan computexQ towithin a given tolerance. Add a method Phi InverseO to Gaussi anthatusesbinary search to compute the inverse. Change mai n() to take a number p between0 and 100 as a third command-line argumentand print the minimum score that astudent would need to be in the top p percent of students taking the SAT in a yearwhen the mean and standard deviation were the first two command-line arguments.

2.1.30 Black-Scholes option valuation. The Black-Scholes formula supplies thetheoretical valueof a European call option on a stockthat pays no dividends, giventhe current stockprice s, the exercise price x, the continuously compounded risk-free interest rate r, the standard deviation a of the stock's return (volatility),and thetime (in years) tomaturity t The value is given by the formula s<&(a) - xe~rtQ>(b)>where <£(z) is the Gaussian cumulative distribution function, a = (ln(s/x) +(r + ct2/2) t) I (vft)y andb=a- aft.Write aprogram thattakes s, x, r, si gma, andt from the command line and prints the Black-Scholes value.

2.1.31 Implied volatility. Typically thevolatility istheunknown value in theBlack-Scholes formula. Write a programthat reads s, x, r, t, and the current price of theEuropean calloption from the commandline and usesbinary search (see Exercise2.1.29) to compute or.

2.1.32 Homers method. Write a class Horner with a method double eval (double

x, doubl e [] p) that evaluates the polynomialp(x) whose coefficients are the entries in p[]:

Po + Pi*1 + P2*2 + ••• + Pn-2*n~2 + Pn-i*n_1

2.1 Static methods

Use Horner's method, an efficient way to perform the computations that is suggested by the following parenthesization:

P0+ *(Pl + *(P2 + "• + *(PiV-2 +*Pn-i)) ••• )Write a testclient witha static methodexp() that uses Horner.eval () to computean approximation to ex, usingthe firstAT termsof the Taylor series expansion ex= 1+ x + x2/2\ + x3/3\ +.... Take an argumentx fromthe command-line, and compareyour result against that computed by Math. exp(x).

2.1.33 Benford's law. The American astronomer Simon Newcomb observed aquirk in a book that compiled logarithm tables: the beginning pages were muchgrubbierthan the endingpages. Hesuspected that scientists performedmore computationswith numbers startingwith 1 than with 8 or 9, and postulated the firstdigit law, which says that under general circumstances, the leading digit is muchmore likely tobe1(roughly 30%) thanthedigit 9 (less than4%). This phenomenonisknown asBenford's law andisnowoften used asastatistical test. Forexample, IRSforensic accountants rely on it to discover taxfraud. Write aprogramthat reads in asequenceof integersfrom standard input and tabulatesthe number of times eachofthe digits 1-9 is the leading digit, breaking the computation into a setof appropriate static methods. Useyour program to test the lawon some tables of informationfrom your computer or from the web. Then, write a program to foil the IRS bygenerating random amounts from $1.00 to $1,000.00 with the same distributionthat you observed.

2.1.34 Binomial distribution. Write a function

public static double binomial(int N, int k, double p)

to compute theprobability ofobtaining exactly kheads iniVbiased coinflips (headswith probabilityp) using the formula

f(N,k,p) =pHl-p)N-kM/(kl(N-k)\).

Hint:Tostaveoff overflow, compute x = Inf(N, k, p) and then return e*. In mai n(),take N and p from the command line and check that the sum over all values of kbetween 0 and JV is (approximately) 1.Also, compare every valuecomputed withthe normal approximation

216

0 Mm

1 •••II

2 ..i.i

3 nil.

4 ilnl

5 .1.1.

6 .11..

7 I...I

8 lull

9 hln


f(N,k,p)~<b(Np,Np(l-p))

(see Exercise 2.2.1).

2.1.35 Coupon collectingfrom a binomial distribution. Develop a version of get-Coupon () that uses bi nomi al () fromthe previous exercise to return couponvaluesaccording to the binomial distribution with p = 1/2. Hint: Generate a uniformlydistributed random number x between 0 and 1, then return the smallest value ofkfor which the sum off(N,j,p) for all j<k exceeds x. Extra credit: Develop a hypothesis for describing the behavior of the coupon collector function under thisassumption.

2.1.36 Chords. Develop a version of PlayThatTune that can handle songs withchords (including harmonics). Develop an inputformat that allows you to specifydifferent durations for each chord and different amplitude weights for each notewithin a chord.Create test files that exercise your programwith variouschordsandharmonics, and create a version of FurElisethat uses them.

2.1.37 Postal bar codes. The barcode used by theU.S. Postal System to routemailisdefined asfollows:Eachdecimaldigit in the zip code is encoded usinga sequence of three half-height and two full-heightbars. The barcode starts and ends with a full-heightbar (theguard rail) and includes a checksum digit (after the five-digit zipcode orZIP+4), computed by summing up the original digits modulo 10. Implement thefollowing functions

• Draw a half-height or full-height bar on StdDraw.• Given a digit,draw its sequence of bars.• Compute the checksum digit.

and a test client that reads in a five- (or nine-) digit zip code as the command-lineargument and draws the corresponding postal bar code.

2.1.38 Calendar. Writea program Calendar that takes two command-line arguments Mand Yand prints out the monthly calendar for the Mth month of year Y, asin this example:

08540 111 •••I••I••I•I••I••1111 ••ImmJ I

guard / guard

checksumdigit

rail

2.1 Static methods

% Java Calendar 2February 2009

M Tu

2 3

9 10

W Th

4 5

11 12

F

6

13 14

2009

S

7

S

1

8

15 16 17 18 19 20 21

22 23 24 25 26 27 28

Hint See LeapYear (Program 1.2.4) and Exercise 1.2.29.

2.1.39 Fourier spikes. Write a program that takes a command-line argument JVand plots the function

(cos(f) + cos(21) + cos(31) +... + cos(Nt)) IN

for 500 equally spaced samples oftfrom -10 to 10 (inradians). Run your programforJV = 5 and JV = 500. Note: You will observe that the sumconverges to a spike(0everywhere except a single value). This property is thebasis fora proof that anysmooth function can be expressedas a sum of sinusoids.

217


2.2 Libraries and Clients

Each program that you havewritten consists of Java code that resides in a single.java file. For large programs, keeping all the code in a single file in this way isrestrictive and unnecessary. Fortunately,it is very easy in Java to refer to a method 2.2.1 Random number library 226in one file that is defined in another. This 2.2.2 Array I/O library 230ability has two important consequences 223 Iterated runction systems 233

7 . r r . ^ 2.2.4 Data analysis library 237on our style ofprogramming. 225 plotting data values mm^ 239First, it enables codereuse. One pro- 2.2.6 Bernoulli trials 242

gram can make use ofcode that is already progmms {n m$ sectimwritten anddebugged, not by copying thecode,but just by referring to it. This ability to define code thatcan bereused isanessential part of modernprogramming. Itamountsto extending Java—you can define anduseyourown operations on data.

Second, it enables modular programming. You cannot only divide a programup intostatic methods, as just described in Section 2.1, but also keep them in different files, grouped together according to the needs of the application. Modularprogramming isimportant because it allows usto independently develop, compile,anddebug parts of bigprograms onepiece atatime,leaving each finished piece inits own file for later usewithout having to worryabout its details again. We developlibraries of static methods for use by any other program, keeping each libraryinits own file and using its methods in any other program. Java's Math library andour Std* libraries for input/output are examples that you havealready used.Moreimportant, youwill soon see thatit isveryeasy to define libraries of yourown.Theability to define libraries and then to use them in multiple programs is a criticalingredient in ourability to buildprograms to address complex tasks.

Having just moved in Section 2.1 from thinking of a Java program as a sequence of statements to thinking of a Java program as a class comprising a setofmethods (one of which is mai n()), you will be readyafter this section to think ofa Java program asa set of classes, each ofwhich is an independent module consisting of a setof methods. Since each method can call a method in another class, allof your code caninteract as a network of methodsthat call one another, groupedtogether in classes. With this capability, you can start to think about managingcomplexity when programming by breaking up programming tasks into classesthat can be implemented and tested independently.


Using static methods in other programs To refer to a staticmethod in oneclass that is defined in another, we use the same mechanism that we have been using to invoke methods such as StdOut. pri ntf () and StdAudi o. pi ay ():

• Keep both classes in the samedirectoryin your computer.• Tocalla method, prepend its class name and a period separator.

For example, consider Gaussian (Program 2.1.2). The definition of one of itsmethods requires the square root function. For purposes of illustration, supposethat we wish to use the sqrt () implementationfrom Newton (Program 2.1.1).Allthatweneedto do isto keep Gaussi an. j ava in thesame directory asNewton. j avaand prepend the class name when calling sqrtQ. If we want to use the standard

SATmyYear.Java

public class SATmyYear{

Gaussian.Javapublic static void main(String[] args){ public class Gaussian

double z = Double.parseDouble(args[0]); {double v =(Gaussian.Phi ((z - 1019)/209);) -

StdOut.println(v);

Newton.java


public static double sqrt(double c){

if (c < 0) return Double.NaN;double err = le-15;double t = c;while (Math.abs(t - c/t) > err * t)

t = (c/t + t) / 2.0;return t;

} . • .

r


doubled a = new double[args.length];for (int i =0; i < args.length; i++)

a[i] = Double.parseDouble(args[i]);for (int i =0; f < allength; i++){

double x <= sqrt(a[i]);StdOut. pri ntl nOO;

}} • ' : -

1 • •public static double Phi(double z){

if (z < -8.0) return 0.0;if (z > 8.0) return 1.0;double sum = 0.0, term = z;for (int i = 3; sum != sum + term; i += 2){

sum = sum + term;

term = term * z * z / i;

}return 0.5 +

1 »(phiOT)

Tcr. sum;

public static double phi(double x){

return Math.exp(-x*x/2) /

(Newton. sqrt(2*Math. PI)p

} 1


double z » Double.parseDouble(args[0]);double mu = Double.parseDouble(args[1]);double sigma » Double.parseDouble(args[2]);StdOut.println(Phi((z - mu) / sigma));

.}*'•••.•

A modularprogram

219


Java implementation, we call Math. sqrt (); if we want to use our own implementation, we call Newton.sqrt(). Moreover, any other class in that directory canmake use of the methods defined in Gaussian, by calling Gaussi an. phi () orGaussi an. Phi(). Forexample, we might wish to have a simple client SATmyYear.Java that takes a value z from the command line and prints <I>((z-1019)/209), sothat we do not need to type in the mean and standarddeviation eachtime we wantto know the percentage scoring less than a given value for a certain year. The filesGaussi an. j ava, Newton. j ava, and SATmyYear. j ava implement Java classes thatinteract with one another: SATmyYear calls a method in Gaussian, which calls amethod that calls a method in Newton.

The potential effectof programming by defining multiple files, each an independent class with multiplemethods,isanother profound change in our programming style. Generally, we refer to this approach asmodular programming. We independentlydevelop and debug methods for an application and then utilize them atany later time. In this section, we will consider numerous illustrative examples tohelp you getused to the idea. However, there are several details about the processthat we need to discussbefore consideringmore examples.

The public keyword. We have been identifying every method as public sinceHel1oWorld. This modifier identifies the method as available for use by any otherprogram with access to the file. You can also identify methods as private (andthere are a fewother categories), but you haveno reason to do so at this point.Wewill discuss various options in Section 3.3.

Each module is a cl ass. We use the term module to refer to all the code that we

keep in a single file. In Java, by convention, eachmodule is a Java cl ass that is keptin a filewith the same name of the class but has a . j ava extension. In this chapter,each class is merely a set of static methods (one of which is main()). You willlearn much more about the general structure of the Java cl ass in Chapter 3.

The .cl ass file. When you compile the program (by typing javac followed bythe class name), the Java compiler makes a file with the class name followed bya .class extension that has the code of your program in a language more suitedto your computer. If you have a .cl ass file, you can use the module's methods inanother program even without having the sourcecode in the corresponding . Javafile (but you areon your own if you discover a bug!).


Compile when necessary. When you compile a program, the Java compilerwillcompile everything that needs to be compiled in order to run that program. If youcallNewton. sqrt () in Gaussi an,then, when you type j avac Gaussi an. j ava, thecompiler will also check whether you modified Newton. Java since the last time itwas compiled (by checking the time it was last changed against the time Newton.cl ass was created). If so, it will alsocompile Newton! If you think about this policy,you will agree that it is actually quite helpful. If you find a bug in Newton (and fixit), you want all the classes that callNewton. sqrt () to use the new version.

Multiple main methods. Another subtlepoint is to note that more than one classmight have a main() method. In our example, SATmyYear, Newton and Gaussi aneachhave mai n() methods. If you recall the rule for executinga program,you willsee that there is no confusion:when you type Java followed by a class name, Javatransfers control to the machine code corresponding to the main() static methoddefinedin that class. Typically, we put a mai n() static method in everyclass, to testand debug its methods. When we want to run SATmyYear, we type Java SATmyYear; when we want to debug Newton or Gaussian,we type j ava Newton or j avaGaussian (with appropriate command-line arguments).

If you think of each program that you write as something that you might want tomake use of later, you will soon find yourselfwith allsortsof useful tools. Modularprogramming allows us to view everysolution to acomputational problem that wemay develop as adding value to our computational environment.

For example, suppose that you need to evaluate <£ for some future application. Why not just cut and paste the code that implements Phi () from Gaussi an?That would work, but would leaveyou with two copiesof the code, making it moredifficult to maintain. If you laterwant to fix or improve it, you would need to do soin both copies. Instead, you can just call Gaussi an. Phi (). Our implementationsand uses of them aresoon going to proliferate, so having just one copy of each is aworthy goal.

From this point forward, you should write every program by identifying areasonable way to divide the computation into separate parts of a manageable sizeand implementing each part as if someone will want to use it later.Most frequently,that someone will be you, and you will have yourself to thank for saving the effortof rewriting and re-debugging code.


Libraries We refer to a module whose methods are primarilyintended for useby many other programs as a library. One of the most important characteristics ofprogramming in Javais that many,many methods have been predefined for you, inliterally thousands of Javalibraries that are available for your use. We reveal information about those that might be of interest toyou throughout the book, but wewillpostponea detailed discussion ofthe scope of Javalibraries until the end of the book, because many ofthem are designed for use by experienced programmers. Instead, we focus in this chapteron the even more important idea that we canbuild user-defined libraries, which are nothingmore than classes that each contain a set of re

lated methods for use by other programs. NoJava library can contain all the methods thatwe might need for a given computation, so thisability is a crucial step in addressing complexprogramming applications.

Clients. We use the term client to refer to

the program that calls a given method. Whena class contains a method that is a client of a

method in another class, we say that the firstclass is a client of the second class. In our ex

ample, Gaussi an is a client of Newton. A givenclass might have multiple clients. For example,all of the programs that you have written thatcall Math.sqrt () or Math. random() are Math clients.When you implement a newstatic method or a new class, you need to havea very clear of idea of what it is goingto do for its clients.

client

calls methods

API

public class Gaussian

double phi (double x) <}>(*)double Phi(double z) <£(z)

implementation

defines signaturesand describes methods

Java code thatimplements methods

Library abstraction

APIs. Programmers normally think in terms of a contract between the client andthe implementation that is a clear specification of what the method is to do. Whenyou are writing both clients and implementations, you are making contracts withyourself,which by itself is helpful because it provides extra help in debugging. Moreimportant, this approach enablescode reuse.Youhave been able to write programs


that are clients of Std* and Math and other built-in Java classes because of an informal contract (an English-languagedescription of what they are supposed to do)along with a precise specification of the signatures of the methods that are available for use. Collectively, this information is known as an application programminginterface (API). This same mechanism is effective for user-defined libraries. TheAPI allows any client to use the library without having to examine the code in theimplementation, just as you have been doing for Mathand Std*. The guiding principle in API design is to provide to clients the methods they need and no others. AnAPIwith a huge number of methods maybe a burden to implement; an API that islacking important methods may be unnecessarilyinconvenient for clients.

Implementations. We usethe term implementation to describe the Java codethatimplements the methods in an API, kept by convention in a file with the libraryname and a .Java extension. EveryJava program is an implementation of someAPI, and no API is of any use without some implementation. Our goal when developing an implementation is to honor the terms of the contract. Often, there aremany waysto do so, and separating client code from implementation code givesusthe freedom to substitute new and improved implementations.

For example, consider the Gaussian distribution functions. These do not appear inJava's Math library but are important in applications, so it is worthwhile for us toput them in a library for use by future client programs and to articulate this API:

public class Gaussian

double phi (double x) §(x)

double phi (double x, double m, double s) §(x, |x,o)

double Phi (double z) $(z)

double Phi (double z, double m, double s) <l>(z, [x, a)

APIforour library ofstatic methodsfor c|) and O

Implementing these four static methods is straightforward from the code in Gauss-ian (Program 2.1.2)—see Exercise 2.2.1. Adding the three-argument versions ofphi () and Phi () to the Gaussian library saves us from having to worry aboutthose cases later on.


Howmuch information should an APIcontain?This isa grayarea and a hotlydebated issueamong programmersand computer-science educators.Wemight tryto put as much information as possiblein the API,but (aswith any contract!) thereare limits to the amount of information that we can productively include. In thisbook, we stick to a principle that parallels our guiding design principle: provideto client programmers the information they need and no more. Doing so gives usvastlymore flexibility than the alternative of providing detailed information aboutimplementations. Indeed, any extra information amounts to implicitly extendingthe contract, which is undesirable. Many programmers fall into the bad habit ofcheckingimplementation code to try to understand what it does. Doing so mightlead to client code that depends on behavior not specified in the API, which wouldnot work with a new implementation. Implementations change more often thanyou might think. For example, each new release of Javacontains many new implementations of library functions.

Often, the implementation comes first. You might have a working modulethat you later decide might be useful for some task, and you can just start usingits methods in other programs. In such a situation, it is wise to carefully articulatethe API at some point. The methods may not have been designed for reuse, so it isworthwhile to use an API to do such a design (as we did for Gaussi an).

The remainder of this section is devoted to several examples of libraries andclients. Our purpose in considering these libraries is twofold. First, they providea richer programming environment for your use as you develop increasingly sophisticated client programs of your own. Second, they serve as examples for you tostudy as you begin to develop libraries for your own use.

Random Burnibers We have writtenseveral programs that useMath. random (),but our code often uses particular idioms that convert the random doubl e valuesbetween 0 and 1 that Math, random() provides to the type of random numbersthat we want to use (random bool ean values or random i nt values in a specifiedrange, for example). To effectively reuse our code that implements these idioms,we will, from now on, use the StdRandom library in Program 2.2.1. StdRandom usesoverloading to generate random numbers from various distributions. You can useany of them in the same way that you use our standard I/O libraries (downloadStdRandom. j ava and keep it in a directory with your client programs, or use youroperating system's classpath mechanism). As usual, we summarize the methods inour StdRandom library with an API:


public class StdRandom

int uniform(int N) integer between 0 and N-1

double uniform(double lo, double hi) real between lo and hi

boolean bernoulli(double p)

double gaussianO

double gaussian(double m, double s)

int discrete(double[] a)

void shuffle (doubled a)

true withprobability p

normal, mean 0, standard deviation 1

normal mean m,standard deviation s

i withprobability a [i ]

randomly shuffle thearray a []

APIfor ourlibrary ofstatic methods for random numbers

These methods are sufficientlyfamiliar that the short descriptions in the API suffice to specifywhat they do. Bycollecting all of these methods that use Math. random () to generate random numbers of various types in one file (StdRandom.j ava),we concentrate our attention on generating random numbers to this one file (andreuse the code in that file) instead of spreading them through every program thatuses these methods. Moreover, each program that uses one of these methods ismore clear than code that calls Math, random() directly, because its purpose forusing Math. random() is clearly articulated by the choice of method from StdRandom.

API design. We makecertainassumptions about the values passed to eachmethod in StdRandom. For example, we assume that clients will call uniform(N) onlyfor positive integers N, bernoul 1i (p) only for p between 0 and 1, and di screteOonly for an array whose entries are between 0 and 1 and sum to 1.All of these assumptions are part of the contract between the client and the implementation.We strive to design libraries such that the contract is clear and unambiguous andto avoid getting bogged down with details. As with many tasks in programming,a good API design is often the result of several iterations of trying and living withvarious possibilities. We always take special care in designing APIs, because whenwe change an API we might have to change all clients and all implementations. Ourgoal is to articulate what clientsare to expectseparatefrom the code in the API.Thispractice frees us to change the code, and perhaps to use an implementation thatachieves the desired effect more efficiently or with more accuracy.

225


5| Program 2.2.1 Random number library

Mm

:^

mm

public class StdRandom{

public static int uniform(int N){ return (int) (Math.random() * N); }

public static double uniform(double lo, double hi){ return lo + Math.random() * (hi - lo); }

public static boolean bernoulli(double p){ return Math.random() < p; }

public static double gaussian(){ /* See Exercise 2.1.28. */ }

public static double gaussian(double m, double s){ return m + s * gaussianO; }

public static int discrete(double[] a){ // See Program 1.6.2.

double r = uniform(0.0, 1.0);double sum = 0.0;for (int i = 0; i < a.length; i++){

sum += a[i];if (sum > r) return i;

}return a.length - 1;

}

public static void shuffle(double[] a){ /* See Exercise 2.2.4. */ }

}

public static void main(String[] args){ /* See text. */ }

This is a library of methods to compute various types of random numbers: random non-negative integer less than a given value, uniformly distributed in a given range, random bit(Bernoulli), Gaussian, Gaussian with given mean and standard deviation, and distributedaccording toa givendiscrete distribution.

% Java StdRandom 590 26.36076 false 8

18.02210 false 9

56.41176 true

79269

0399213

58 8.80501

29 16.68454 false 8.90827

85 86.24712 true 8.95228

!

'"WreS.-SfiK^v' s^pllPP^l^i^lsPiFWmir-^yw^^^^v^^^^Ws^W^^^^^

!:•••

iIft

II

ft

s

m

$


Unit testing. Even though we implement StdRandom without reference to anyparticular client, it is good programming practice to include a test client mai n()that, although not usedwhen a clientclass uses the library, is helpfulfor use whendebugging and testing the methods in thelibrary. Wheneveryou create a library, youshould include a mai n() methodfor unittesting and debugging. Proper unit testingcan be a significantprogramming challenge in itself (for example, the best way oftesting whether the methods in StdRandom produce numbers that have the samecharacteristics as truly random numbers is stilldebated by experts).At a minimum,you should always include a mai n() method that

• Exercises all the code

• Provides some assurance that the code is working• Takes an argument from the command line to allowmore testing

Then, you should refine that mai n() method to do more exhaustive testing as youuse the library more extensively. For example, we might start with the followingcode for StdRandom (leavingthe testing of shuff1e() for an exercise):


int N = Integer.parselnt(args[0]);double[] t = { .5, .3, .1, .1 };for (int i = 0; i < N; i++)

{StdOut.printf(" %2d " , uniform(lOO));StdOut.printf(M%8.5f M, uniform(10.0, 99.0));StdOut.printf(M%5b " , bernoulli(.5));StdOut.printf("%7.5f ", gaussian(9.0, .2));StdOut.printf("%2d " , discrete(t));StdOut.println();

}}

When we include this code in StdRandom. Java and invoke this method as illustrated in Program 2.2.1, the output carries no surprises: the integers in the firstcolumn might be equallylikely to be any value from 0 to 99; the numbers in thesecond column might be uniformly spread between 10.0 and 99.0; about half ofthe values in the third column are true; the numbers in the fourth column seem to

average about 9.0, and seem unlikely to be too far from 9.0; and the last columnseems to be not far from 50% 0s, 30% Is, 10% 2s, and 10% 3s. If something seemsamiss in one of the columns, we can type Java StdRandom 10 or 100 to see many


more results. In this particular case,we can (and should) do far more extensivetestingin a separate client to check thatthenumbers have many of thesame propertiesas truly random numbers drawn from the cited distributions (seeExercise 2.2.3).One effective approach is to write test clients that use StdDraw,as data visualizationcan be a quick indication that a program is behaving as intended. For example, aplot of a large number of points whose x and y coordinates are both drawn from

various distributions often producesa pattern that gives direct insight intothe important properties of the distribution. More important, a bug inthe random number generation codeis likely to show up immediately insuch a plot.

public class RandomPoints{


int N = Integer.parselnt(args[0]);for (int i = 0; i < N; i++)

{double x = StdRandom.gaussian(.5, .2);double y = StdRandom.gaussian(.5, .2);StdDraw.point(x, y); Stress testing. An extensively usedli

brary such as StdRandom should alsobe subject to stress testing, where wemake sure that it does not crash when

the client does not follow the contract

or makes some assumption that is notexplicitly covered. You can be surethat Java libraries have been subjectto such testing, which requires carefullyexamining each line of code andquestioning whether some conditionmight cause a problem. What shoulddiscrete() do if array entries donot sum to exactly 1?What if the argument is an array of size 0? Whatshould the two-argument uniformO

do if one or both of its arguments is NaN? Infi ni ty? Any question that you canthink of is fair game. Such cases are sometimes referred to as corner cases. You arecertain to encounter a teacher or a supervisor who is a stickler about corner cases.With experience, most programmers learn to address them early, to avoid an unpleasant bout of debugging later. Again, a reasonable approach is to implement astress test as a separate client.

}}

A StdRandom test client


Input and output for arrays We have seenand willseemanyexamples wherewe wish to keep data in arrays for processing. Accordingly, it is useful to build alibrary of static methods that complements Stdln and StdOut by providing staticmethods for reading arrays of primitive types from standard input and printingthem to standard output, as expressed in this API:

public class StdArraylOdoubl e [] readDoubl elD() read a one-dimensional array o/doubl e values

doubl e [] [] readDoubl e2D() read a two-dimensional array o/doubl e values

voi d pri nt (doubl e [] a) print a one-dimensional array o/doubl e values

voi d pri nt (doubl e [] [] a) print a two-dimensional array o/doubl e values

Notes:

1. IDformatisan integer N followed byN values.

2. 2D format is two integers M andNfollowed by MxN values in row-major order.

3. Methods for i nt and bool ean arealsoincluded.

APIfor ourlibrary ofstatic methodsfor array input andoutput

The first two notes at the bottom of the table reflect the idea that we need to settle

on afileformat. For simplicity and harmony,we adopt the convention that all values appearing in standard input include the dimension(s) and appear in the orderindicated. The read*() methods expect this format, the print() methods produce output in this format, and we can easily create files in this format for datafrom some other source. The third note at the bottom of the table indicates that

StdArraylO actually contains twelve methods—four each for int, double, andboolean. The print() methods are overloaded (they all have the same namepri nt() but different types of arguments), but the read* () methods need differentnames, formed by adding the type name (capitalized, as in Stdln) followed by IDor 2D.

Implementing these methods is straightforward from the array-processingcode that we have considered in Section 1.4 and in Section 2.1, as shown in StdAr

raylO (Program 2.2.2). Packaging up all of these static methods into one file—StdArraylO. Java—allows us to easily reuse the code and saves us from havingto worry about the details of reading and printing arrayswhen writing client programs later on.


mm^^^^^^^^^^^^^^^^^mms^

*0$l

Program2.2.2 Array I/O library

public class StdArraylO{

public static doubled readDoublelD(){ /* See Exercise 2.2.6 */ }

public static doubled [] readDouble2D(){

int M = Stdln.readlntO;int N = Stdln.readlntO;doubled [] a = new double[M] [N];for (int i = 0; i < M; i++)

for (int j = 0; j < N; j++)a[i][j] = Stdln.readDouble();

return a;

}

public static void print (doubled a){ /* See Exercise 2.2.6 */ }

public static void pri nt (doubl e [] [] a){

int M = a.length;int N = a[0].length;System.out.println(M + " " + N);for (int i = 0; i < M; i++){

for (int j = 0; j < N; j++)StdOut. print (a [i][j] + " ");

StdOut.println();}StdOut.println();

}

// Methods for other types are similar (see booksite),

public static void main(String[] args){ print(readDouble2D()); }

}

% more tiny.txt4 3

.000

.246

.222

-.032

.270 .000

.224 -.036

.176 .0893

.739 .270

% Java StdArraylO < tiny.txt4 3

0.00000

0.24600

0.22200

-0.03200

0.27000

0.22400

0.17600

0.73900

0.00000

-0.03600

0.08930

0.27000

5^?nH||!

m

This library of static methods facilitates reading one-dimensional and two-dimensional arrays from standard input and printing them to standard output. Thefileformat includes thedimensions (see accompanying text). Numbers in the output in the example are truncated.

2.2 libraries and Clients 231

Iterated faiHCtioB systems Scientists havediscovered that complexvisual images can arise unexpectedly from simple computational processes. With StdRandom, StdDraw, and StdArraylO, we can easily study the behavior of such systems.

Sierpinksi triangle. As a first example, consider the following simple process:Start by plotting a point at one of the vertices of a given equilateraltriangle. Thenpick one of the three vertices at random and plot a new point halfway between thepoint just plotted and that vertex. Continue performing this same operation. Eachtime, we are picking a random vertexfrom the triangle to establishthe line whosemidpoint willbe the next point plotted. Since we are making a random choice,theset of points should have some of the characteristics of random points, and thatdoes seem to be the case after the first few iterations:

(1/2, N3/2) last point

(0,0)random vertex

A random process

But we can study the process for a large number of iterations by writing a programto plot T points according to the rules:

doubled ex = { 0.000, 1.000, 0.500 };doubled cy = { 0.000, 0.000, 0.866 };double x=0.0, y=0.0;for (int t = 0; t < T; t++){

int r = StdRandom.uniform(3);x = (x + cx[r]) / 2.0;y = (y + cy[r]) / 2.0;StdDraw.point(x, y);

}

Wekeepthe x and/ coordinatesof the trianglevertices in the arraysex[] and cy[],respectively. Weuse StdRandom. uni form() to choosea random index r into these


arrays—the coordinates of the chosen vertex are (cx[r], cy [r]). The x-coordi-nateof themidpoint of the line from (x, y) to thatvertex isgiven bytheexpression(x + ex[r]) /2.0, and a similar calculation gives they coordinate. Adding a call toStdDraw. point () and putting this code in a loop completes the implementation.Remarkably, despite the randomness, the samefigure always emerges aftera largenumber of iterations! This figure is known as the Sierpinski triangle (see Exercise2.3.27). Understandingwhysuch a regularfigure should arise from such a randomprocess is a fascinating question.

A A•*

•. -... -"t •:'* A i\ A a

A random process?

Barnsleyfern. To addto themystery, we canproduce pictures ofremarkable diversityby playing the samegamewith different rules. One strikingexample is knownas the Barnsley fern. To generate it, we use the same process, but this time drivenby the following table of formulas. At each step,we choose the formulas to use toupdate x and y with the indicated probability (1% of the time we use the first pairof formulas, 85% of the time we use the secondpair of formulas, and so forth).

probability x-update y-update

1% x= .500 x= A60y85% x = .85*+ .04/ + .075 / = .04* + .85/ + .180

7% x = .20* - .26/ + .400 y = 23x + .22/ + .045

7% x = A5x+ .28/ + .575 / = .26* + .24/ - .086

We couldwritecode just like the code we just wrote for the Sierpinski triangle toiteratethese rules, but matrixprocessing provides a uniformway to generalize that


f&#

U:-s.

Program 2.2.3 Iteratedfunction systems

public class IFS{

public static void main (St ring argsd){ // Plot T iterations of IFS on Stdln.

int T = Integer.parselnt(args[0]);double[] dist = StdArraylO.readDoublelD();

ex = StdArraylO.readDouble2D();cy = StdArraylO.readDouble2D();0.0, y = 0.0;=0; t < T; t++)

// Plot 1 iteration.int r = StdRandom.discrete(dist);

doubled []doubled []double x =

for (int t

{

T

dist[]

cx[][]

cy[][]

x, y

double xO = cx[r][0]*xdouble yO = cy[r][0]*xx = xO;

y = yO;StdDraw.point(x, y);

cx[r][l]*ycy[r][l]*y

cx[r][2];cy[r][2];

}

iterations

probabilities

x coefficients

y coefficients

currentpoint

This data-driven client ofStdArraylO, StdRandom, andStdDraw iterates thefunction systemdefined bya l-by-M vector (probabilities) and two M-by-3 matrices (coefficients for updatingx andy respectively) on standard input, plotting the result as a set ofpoints on standarddraw. Curiously thiscode does not need to know thevalue ofM, as it uses separate methodsto create and process the matrices.

% more sierpinski.txt

3

.33 .33 .34

3 3

.50 .00 .00

.50 .00 .50

.50 .00 .25

3 3

.00 .50 .00

.00 .50 .00

.00 .50 .433

•»4HI«WMI^^

% Java IFS 10000 < sierpinski.txt

T^s^s»!p^^^»i^^^^^^^^pp 5K^* WSg^mm^^mm!?PP?flIl|!

234

% more barnsley.txt4

.01 .85 .07 .07

4 3

.00 .00 .500

.85 .04 .075

.20 -.26 .400

-.15 .28 .575

4 3

.00 .16 .000

-.04 .85 .180

.23 .22 .045

.26 .24 -.086

% more tree .txt

6

.1 .1 .2 .2 .2 .2

6 3

.00 .00 .550

-.05 .00 .525

.46 - .15 .270

.47 - .15 .265

.43 .26 .290

.42 .26 .290

6 3

.00 .60 .000

-.50 .00 .750

.39 .38 .105

.17 .42 .465

-.25 .45 .625

-.35 .31 .525

more coral.txt

.40 .15 .45

3 3

.3077 - .5315 .8863

.3077 - .0769 .2166

.0000 .5455 .0106

3 3

-.4615 - .2937 1.0962

.1538 - .4476 .3384

.6923 - .1958 .3808


% Java IFS 20000 < barnsley.txt

Java IFS 20000 < tree.txt

% Java IFS 20000 < coral.txt

Examples of iteratedfunction systems


code to handle any set of rules.WehaveM different transformations, chosen froma 1-by-M vector with StdRandom.discrete(). For each transformation, we havean equation for updating x and an equation for updating /, so we use two M-by-3matrices for the equation coefficients, one for x and one for/. IFS (Program 2.2.3)implements this data-driven version of the computation. This program enableslimitless exploration: it performs the iteration for any input containing a vectorthat defines the probability distribution and the two matrices that define the coefficients, one for updating x and the other for updating /. For the coefficients justgiven, again, even though we choose a random equation at each step, the same figure emerges every time that we do this computation: an image that looks remarkably similar to a fern that you might see in the woods, not something generated bya random process on a computer.

Generating a Barnsleyfern

That the same short program that takes a few numbers from standard input andplots points on standard draw can (given different data) produce both the Sierpinski triangle and the Barnsley fern (and many, many other images) is truly remarkable. Becauseof its simplicity and the appeal of the results, this sort of calculationis useful in making synthetic images that have a realistic appearance in computer-generated movies and games. Perhaps more significantly, the ability to producesuch realistic diagrams so easilysuggestsintriguing scientificquestions: What doescomputation tell us about nature? What does nature tell us about computation?


Standard statistics Next, we considera library for a set of mathematical calculations and basicvisualization tools that arise in all sorts of applications in science and engineeringand are not all implemented in standard Java libraries.Thesecalculations relateto the taskof understandingthe statistical properties of a set ofnumbers. Such a library is useful, for example, when we perform a seriesof scientificexperiments that yieldmeasurements of a quantity.One of the most importantchallenges facing modern scientists is proper analysis of such data, and computation is playing an increasingly important role in such analysis. These basic dataanalysis methodsthat wewill consider are summarized in the following API:

public class StdStats

double max(doubled a) largest value

double mi n (doubl e[] a) smallest value

double mean(doubled a) average

double var(double[] a) sample variance

double Stddev(double[] a) sample standard deviation

double medi an (doubl e[] a) median

void pi otPoints (doubl e[] a) plot points at (i, aim

void pi OtLines (doubled a) plotlines connectingpoints at (i, a[i])

void pi otBars (doubl e[] a) plot bars to points at Qi^W)

Note: overloaded implementations areincludedfor all numeric types

APIfor ourlibrary ofstatic methodsfor dataanalysis

Basic statistics. Suppose that wehave Nmeasurements x0> xv.., xN_v The averagevalue of those measurements, otherwise known as the mean, is given by the formula |x = (x0 + xx + ... 4- xN_x) /Nand isan estimateof the valueof the quantity.The minimum and maximum values are also ofinterest, as is the median (the valuewhich issmaller than and larger than halfthevalues). Also of interestis the samplevariance, which is givenby the formula

a2 = ((x0-(ji)2 + (^-^)2 + ... + (%-i-|x)2))/(N-l)


1

m

mm.

m

Program 2.2.4 Data analysis library

public class StdStats{

public static double max(double[] a){ // Compute maximum value in a[].

double max = Double.NECATIVE_INFINITY;for (int i = 0; i < a.length; i++)

if (a[i] > max) max = a[ij;return max;

}

public static double mean(double[] a){ // Compute the average of the values in a[].

double sum =0.0;for (int i = 0; i < a.length; i++)

sum = sum + a[i];return sum / a.length;

}

public static double var(double[] a){ // Compute the sample variance of the values in a[],

double avg = mean(a);double sum =0.0;for (int i = 0; i < a.length; i++)

sum += (a[i] - avg) * (a[i] - avg);return sum / (a.length - 1);

}

public static double stddev(double[] a){ return Math.sqrt(var(a)); }

// See Program 2.2.5 for plotting methods.

public static void main(String[] args){ /* See text. */ }

This code implements methods tocompute the maximum, mean, variance, andstandard deviation ofnumbers in a client array. The methodforcomputing the minimum isomitted, andplotting methods are in Program 2.2.5 (see Section 4.2for a discussion of themedian).

% more tiny.txt5

3.0 1.0 2.0 5.0 4.0

237

i

mw

I-

I

km

m

ffl1

ipi

% Java StdStats < tiny.txtmin 1.000

mean 3.000

max 5.000

std dev 1.581

3^^^^^^^^^^^^m^^^^^^^^^^^^^^^^^^^^^^1'


and the sample standard deviation, the square root of the sample variance. StdStats (Program 2.2.3) shows implementations of static methods for computingthese basic statistics (the median is more difficultto compute than the others—wewill consider the implementation of medi an () in Section 4.2). The main() test client for StdStats reads numbers from standard input into an array and callseachof the methods to print out the minimum, mean, maximum, and standard deviation, as follows:


doublet] a = StdArraylO.readDoublelD();StdOut.printf(" min %7.3f\n", min(a));StdOut.printf(" mean %7.3f\n", mean(a));StdOut.printf(" max %7.3f\n", max(a));StdOut.printf(" std dev %7.3f\n", stddev(a));

}

As with StdRandom, a more extensive test of the calculations is called for (see Exercise 2.2.3). Typically, as we debug or test new methods in the library, we adjustthe unit testing code accordingly, testing the methods one at a time. A mature andwidelyused library likeStdStats alsodeserves a stress-testingclient for extensivelytesting everything after any change.If you are interested in seeingwhat such a clientmight look like, you can find one for StdStats on the booksite. Most experiencedprogrammers will adviseyou that any time spent doing unit testing and stress testing will more than pay for itself later.

Plotting. One important use of StdDraw is to help us visualize data rather thanrelying on tables of numbers. In a typical situation, we perform experiments, savethe experimental data in an array, and then compare the results against a model,perhaps a mathematical function that describes the data. To expedite this processfor the typical casewhere values of one variable are equally spaced, our StdStatslibrary contains static methods that you can use for plotting data in an array. Program 2.2.5 is an implementation of the plotPoints(), plotLinesO, and plot-Bars() methods for StdStats. These methods display the values in the argumentarray at regularly spaced intervals in the drawing window, either connected together by line segments (1i nes), filled circles at each value (poi nts), or bars fromthe x-axis to the value (bars). They all plot the points with x coordinate i and ycoordinate a[i ] using filled circles, linesthrough the points, and bars, respectively.


Wm

ft

wm

till

Program 2.2.5 Plotting data values in an array

public static void piotPoints(double[] a){ // Plot points at (i, a[i]).

int N = a.length;StdDraw.setXscale(0, N-1);StdDraw.setPenRadius(l/(3.0*N));for (int i =0; i < N; i++)

StdDraw.point(i, a[i]);

}

public static void piotLines(double[] a){ // Plot lines through points at (i, a[i]),

int N = a.length;StdDraw.setXscale(0, N-1);StdDraw.setPenRadius();for (int i = 1; i < N; i++)

StdDraw.line(i-l, a[i-l], i, a[i]);

}

public static void piotBars(double[] a){ // Plot bars from (0, a[i]) to (i, a[i]).

int N = a.length;StdDraw.setXscale(0, N-1);StdDraw.setPenRadius(0.5 / N);for (int i = 0; i < N; i++)

StdDraw.1ine(i, 0, i, a[i]);

}

^^fe^tii^î^'ôÛ*.*;:1;

This code implements three methods in StdStats (Program 2.2.4) for plotting data. Theyplot thepoints (i, a[i ]) withfilled circles, connecting linesegments, and bars, respectively.

plotPoints(a); piotLines(a); piotBars(a); f

int N = 20;double[] a = new doubl e[N];for (int i = 0; i < N; i++)

a[i] = 1.0/Ci+l);

^Ss^KswgEiPsl^ysjsiss^

llllllllllliiii


They all rescale x to fill the drawingwindow (so that the points are evenlyspacedalong the x-coordinate) and leave to the client scalingthe y-coordinates.

These methods are not intended to be a general-purpose plotting package,you can certainlythink of all sorts of things that you might want to add: differenttypesof spots,labeledaxes, color, and manyother artifacts are commonlyfound inmodern systems that can plot data. Some situations might call for more complicated methods than these.

Our intent with StdStats is to introduce you to data analysiswhile showingyou how easyit is to definea library to take care of useful tasks.Indeed, this libraryhas alreadyproven useful—we use theseplotting methods to produce the figures inthis book that depict function graphs,sound waves, and experimental results.Next,we consider severalexamples of their use.

Plotting function graphs. You can usethe StdStats. pi ot* () methods to draw aplot of the function graph for any functionat all: choose an x-interval where you wantto plot the function, compute functionvalues evenly spaced through that intervaland store them in an array, determine andset the y scale, and then call StdStats.pi otLi nes () or another plot*() method. For example, to plot a sine function,rescale the y-axis to cover values between—1 and +1. Scaling the x-axis is automaticallyhandled by the StdStats methods. Ifyou do not know the range, you can handle the situation by calling:

StdDraw.setYscale(StdStats.mi n(a), StdStats.max(a));

The smoothness of the curve is determined by properties of the function and bythe number of points plotted. Aswediscussedwhen first considering StdDraw,youhave to be careful to sample enough points to catch fluctuations in the function.Wewillconsider another approach to plotting functions based on sampling valuesthat are not equally spaced in Section 2.4.

int N = 50;doubled a = new double[N+l];for (int i = 0; i <= N; i++)

a[i] = Gaussian.phi(-4.0 + 8.0*i/N);StdStats.piotPoi nts(a);StdStats.piotLi nes(a);

Plottingafunctiongraph


Plottingsound waves. Both the StdAudi o libraryand the StdStats plot methodswork with arrays that contain sampled values at regular intervals. The diagrams ofsound waves in Section 1.5and at the beginning of thissection were each produced by first scaling the /-axis StdDraw. setYscal e(-1.0, 1.0);

withStdDraw.setYscaleC-l, 1), then plotting the ^^UyTnltTune.tone(880, .01);points with StdStats.piotPoints(). As you have StdStats.piotPoints(hi);seen, such plots give direct insight into processing au- ^ ^ ^ ^dio. You can also produce interesting effects by plot- / \ting sound wavesas you play them with StdAudio, although this task is a bit challenging because of the '^ '^ '^huge amount ofdata involved (see Exercise 1.5.23). Plotting asound wave

Plotting experimental results You can put multipleplots on the samedrawing. One typical reasonto do so is to compareexperimentalresults with a theoretical model. For example, Bernoulli (Program 2.2.6) countsthe number of heads found when a fair coin is flipped N times and compares theresult with the predicted normal (Gaussian) distribution function. A famous resultfrom probability theory is that the distribution of this quantity is the binomialdistribution, which is extremely well-approximated by the normal distributionfunction c|> with mean N/2 and standard deviation yjN/2. The more often we runthe experiment, the more accurate the approximation. The drawing produced byBernoul 1i is a succinct summary of the results of the experiment and a convincing validation of the theory. This example is prototypical of a scientific approachto applications programming that we use often throughout this book and that youshould use whenever you run an experiment. If a theoretical model that can explain your resultsis available, a visualplot comparingthe experiment to the theorycan validate both.

These few examples are intended to indicate to you what is possible with a well-designed library of static methods for data analysis. Several extensions and otherideas are explored in the exercises. You will find StdStats to be useful for basicplots, and you are encouraged to experiment with these implementations and tomodify them or to add methods to make your own library that can draw plots ofyour own design.Asyou continue to address an ever-wideningcircle of programming tasks, you will naturally be drawn to the idea of developing tools like thesefor your own use.


i -•;ste^^

III

m

m

Program 2.2.6 Bernoulli trials

public class Bernoulli{

public static int binomial(int N){ // Simulate flipping a coin N times,

int heads = 0;for (int i = 0; i < N; i++)

if (StdRandom.bernoulli(0.5)) heads++;return heads;

}public static void main(String[] args){ // Perform experiments, plot results and model,

int N = Integer.parselnt(args[0]);int T = Integer.parselnt(args[l]);

}

int[] freq = new int[N+l];for (int t = 0; t < T; t++)

freq[bi nomi al(N)]++;

doubled norm = new double[N+l];for (int i =0; i <= N; i++)

norm[i] = (double) freq[i] / T;StdStats.piotBars(norm);

double stddev = Math.sqrt(N)/2.0;double stddev = Math.sqrt(N)/2.0;doubled phi = new double[N+l];for (int i = 0; i <= N; i++)

phi [i] = Gaussian.phi(i, mean, stddev);StdStats.piotLi nes(phi);

N

T

freq[]

norm[]

phi[]

number offlipsper trial

number of trials

experimental results

normalized results

Gaussian model

This StdStats, StdRandom, and Gaussian clientprovides convincing visual evidence thatthe number of heads observed whenafair coin isflippedN timesobeys a Gaussian distribution. It uses theoverloaded Gaussi an. phi () thattakes asarguments themean andstandarddeviation (see Exercise2.2.1).

% Java Bernoulli 20 100000

-wffllW.


Modular programming The libraryimplementations that wehave developedillustrate a programming styleknown as modular programming. Instead of writinga new program that is self-contained in its own file to address a new problem, webreak up each task into smaller, more manageable subtasks, then implement andindependently debug code that addresses each subtask. Good libraries facilitatemodular programming by allowingus to define and to provide solutions of important subtasks for future clients. Whenever you can clearly separate tasks within aprogram, youshould doso. Javasupports such separation by allowingus to independently debug and later use classes in separate files. Traditionally, programmers usethe term module to refer to code that can be compiled and run independently; inJava each class is a module.

IFS (Program 2.2.3) exemplifies modular programming because it is a relatively sophisticated computation that isimplemented with several relatively smallmodules, developed independently. It usesStdRandom and StdArraylO), as well as themethods from Integer and StdDraw that weare accustomed to using. If we were to putall of the code required for IFS in a singlefile, we would have a large amount of codeon our hands to maintain and debug; withmodular programming, we can study iterated function systemswith some confidencethat the arrays are read properly and that therandom number generator will produce properly distributed values, because wealready implemented and tested the code for these tasks in separate modules.

Similarly, Bernoulli (Program 2.2.6) also exemplifies modular programming. It is a client of Gaussian, Integer, Math, StdRandom, and StdStats. Again,we can have some confidence that the methods in these modules produce the expected results because they are system libraries or libraries that we have tested,debugged, and used before.

Todescribe the relationships among modules in a modular program, we oftendraw a dependencygraph, where we connect two classnames with an arrow labeledwith the name of a method if the first class contains a call on the method and the

second class contains the definition of the method. Such diagrams play an impor-

243

API description

Gaussian Gaussian distribution functions

StdRandom random numbers

StdArraylO input and output for arrays

IFS client for iterated function systems

StdStats functions for data analysis

Bernoulli client for Bernoulli trials experiments

Summary of classes in thissection

244

readDoublelDO

readDouble2D()

readDoubleO,readlnt()


Dependency graph for themodules in thissection

tant role because understanding the relationships among modules is necessary forproper development and maintenance.

We emphasize modular programming throughout this book because it hasmany important advantages that have come to be accepted as essential in modernprogramming, including the following:

• We can have programs of a reasonable size,even in large systems.• Debugging is restricted to small piecesof code.• We can reuse code without having to reimplement it.• Maintaining (and improving) code is much simpler.

The importance of these advantages is difficult to overstate, so we will expand uponeach of them.

Programs of a reasonable size. No large taskis so complex that it cannotbe divided into smaller subtasks. If you find yourself with a program that stretches tomore than a few pages of code, you must ask yourself the following questions: Arethere subtasks that could be implemented separately? Do some of these subtaskslogicallygroup together in a separate library? Could other clients use this code inthe future? At the other end of the range, if you find yourself with a huge numberof tiny modules, you must ask yourself questions such as: Is there some group ofsubtasks that logicallybelong in the same module? Is each module likelyto be usedby multiple clients? There is no hard-and-fast rule on module size: one implemen-


tation of a critically important abstraction might properlybe a few lines of code,whereas another librarywith a large numberof overloaded methods might properly stretch to hundreds of lines of code.

Debugging. Tracing a program rapidly becomes more difficult as the number ofstatements and interacting variables increases. Tracing a program with hundredsofvariables requires keeping track ofhundreds ofvalues, as any statement mightaffect or be affected by any variable. To do so for hundreds or thousands of statements or more is untenable. With modular programming and our guiding principle of keeping the scope of variables local to the extent possible, we severely restrict thenumber ofpossibilities thatwe have to consider when debugging. Equallyimportant is the idea of a contractbetween client and implementation. Once weare satisfied thatanimplementation ismeeting its endofthebargain, we can debugall its clients under that assumption.

Code reuse. Oncewehave implemented libraries suchas StdStats and StdRandom, we do not have to worry aboutwriting code to compute averages or standarddeviations or to generate random numbers again—we can simply reuse the codethatwe have written. Moreover, we do not need to make copies of the code: anymodule canjust refer to anypublic method in any othermodule.

Maintenance. Like a good piece of writing, a good program can always be improved, andmodular programming facilitates the process ofcontinually improvingyour Java programs becauseimprovinga module improves allof its clients. For example, it isnormally thecase that there are several different approaches to solvinga particular problem. Withmodularprogramming, youcanimplement more thanone and trythem independently. More importantly, suppose thatwhile developinga new client, you find a bug in some module. With modular programming, fixingthat bug amounts to fixing bugs in allof the module's clients.

If you encounter an old program (or a new program written byan old programmer!), you are likely to find one huge module—a long sequence of statements,stretching to several pages or more, where anystatement can refer to anyvariablein the program. Variables whose scope extends to a whole program areknown asglobal variables. We avoid global variables in modular programs, but their use iscommon in lower-level and olderprogramming languages. Hugemodulesthat use


global variables are extremely difficult to understand, maintain, and debug. Oldprograms of thiskindarefound in critical partsof our computational infrastructure (for example, some nuclear power plants and some banks) precisely becausethe programmers charged with maintaining them cannot even understand themwell enough to rewrite them inamodern language! With support formodular programming, modern languages like Java help usavoid such situations byseparatelydeveloping libraries of methods in independent classes.

The ability to share static methods among different files fundamentally extends our programming model in two different ways. First, it allows us to reusecode without having to maintain multiple copies of it. Second, by allowing us toorganize a program into files of manageable size that can be independently debugged and compiled, it strongly supports our basic message: Whenever you canclearly separate tasks within aprogram, you should do so. We use theterm library tocapture the idea of developing methods for later reuse and modular programmingto capture the idea of independently developing pieces connected bywell-definedinterfaces instead of a big,monolithic pieceof code.

In this section, wehave supplemented the Std* libraries of Section 1.5 withseveral other libraries that you can use: Gaussian, StdArraylO, StdRandom, andStdStats. Furthermore, we have illustrated their use with several client programs.Thesetoolsare centeredon basicmathematical concepts that arise in anyscientificproject orengineering task. Our intent is notjust toprovide tools, butalso to illustrate to you that it iseasy for you to create your own tools. The first question thatmost modern programmers ask when addressing a complex task is"What tools doI need?" When the needed tools are not conveniently available, the second questionis"Howdifficult would it be to implementthem?" To be a good programmer, youneed to havethe confidenceto build a software tool when you need it and the wisdom to knowwhenit mightbebetterto seek a solutionin a library.

After libraries and modular programming, youhave one morestepto learnacomplete modern programming model: object-oriented programming, the topic ofChapter3.Withobject-oriented programming, youcanbuildlibraries of functionsthat use side effects (in a tightlycontrolled manner) to vastly extend the Java programming model. Before moving to object-oriented programming, we consider inthischapter the profound ramifications of the idea that any method cancall itself(in Section 2.3) and a more extensive case study (in Section 2.4) of modular programming than the smallclients in this section.


Q. I tried to use StdRandom, but got the error message Exception in thread"main" java.lang.NoClassDefFoundError: StdRandom. What'swrong?

A. You needto download StdRandom. Java into the directory containing yourclient, or use your operating system'sclasspath mechanism, as described on the book-site.

Q. Isthere a keyword that identifies a class asa library?

A. No, any setofpublic methods will do. There isabit ofa conceptual leap in thisviewpoint because it is one thing to sit down to create a .Java file that you willcompile and run, quite another thing to create a .Java file that you will rely onmuch later in the future, and stillanother thing to create a . Java file for someoneelse to usein the future. You needto develop some libraries foryourownusebeforeengaging in thissort of activity, which isthe province of experienced systems programmers.

Q. How doI develop a new version ofalibrary thatI have been using for a while?

A. With care. Any change to theAPI might break any client program, so it isbesttowork ina separate directory. Butthenyou are working with a copy of thecode. Ifyou are changing a library thathas a lotofclients, you can appreciate the problemsfaced bycompanies putting out new versions of their software. Ifyou justwant toadd a few methods to alibrary, go ahead: that isusually nottoodangerous, thoughyou should realize that you might find yourself in a situation where you have tosupport that library for years!

Q. How doI know thatanimplementation behaves properly? Why notautomatically check that it satisfies the API?

A. We use informal specifications because writing a detailed specification is notmuch different than writing a program. Moreover, a fundamental tenet of theoretical computer science says that doing sodoes not even solve thebasic problem,because generally there isnoway to check thattwo different programs perform thesame computation.


TxercisSImmm^^^1^

2.2.1 Add to Gaussi an (Program 2.1.2) the method implementation phi (x, mu,si gma) specified in the API that computes the Gaussian distribution with a givenmean jx andstandarddeviation a, basedon the formula${x, |x,a) = <J>( (x- |x)/a)/a.Also include the implementation of the associated cumulative distribution function Phi (z, mu, si gma),based on the formula 4>(z, |x,a) = 0((z-|x)/a).

2.2.2 Write a static method library that implements the hyperbolic trigonometric functions based on the definitions sinh(x) = (ex - e~x)/2 and cosh(x) = (ex +e~x)/2, with tanh(x), coth(x), sech(x), and csch(x) defined in a manner analogousto standard trigonometric functions.

2.2.3 Write a test client for both StdStats and StdRandom that checks that themethods in both libraries operateas expected. Take a command-line argument N,generate N random numbers using each of the methods in StdRandom, andprintout their statistics. Extra credit: Defendthe resultsthat you getby comparing themto those that are to be expectedfrom analysis.

2.2.4 Add to StdRandom a method shuff 1e () that takes an array of doubl e values as argument andrearranges them inrandom order. Implement atest client thatchecks that each permutation of the array isproduced about the same number oftimes.

2.2.5 Develop a client that does stress testing for StdRandom. Pay particular attention to di screte(). For example, do the probabilities sum to 1?

2.2.6 Develop a full implementation ofStdAr ray10(implement all 12 methodsindicated in the API).

2.2.7 Write a method that takes doubl e values ymi n and ymax (with ymi n strictlyless than ymax), and a double arraya[] asarguments and uses the StdStats libraryto linearly scale thevalues in a[] sothat they areall between ymi nand ymax.

2.2.8 Writea Gaussi an and StdStats clientthat exploresthe effects of changingthe mean and standard deviation on the Gaussian distribution curve. Create one

plotwith curves having a fixed mean andvarious standard deviations andanotherwith curveshavinga fixed standard deviationand various means.


2.2.9 Add to StdRandom a static method maxwellBoltzmannC) that returns arandom value drawn from a Maxwell-Boltzmann distribution with parameter o\To produce sucha value, return the square root of the sum of the squares of threeGaussian random variables with mean0 and standard deviation a. The speeds ofmoleculesin an ideal gashave a Maxwell-Boltzmann distribution.

2.2.10 Modify Bernoul 1i (Program 2.2.6) to animate thebargraph, replotting itaftereachexperiment, sothat youcanwatch it converge to the normaldistribution.Thenadda command-line argument andan overloaded binomi al () implementation to allow youto specify theprobabilityp that abiased coincomes up heads, andrun experiments to geta feeling for thedistribution corresponding to a biasedcoin.Be sure to try values of p that are close to 0 and close to 1.

2.2.11 Write a library Mat ri x that implements the following API:

public class Matrix

double dot(double[] a, doubled b)

doubled [] mu! ti ply (doubl e[][] a, doublet] [] b)

doubled [] transpose(double[][] a)

doubled multiply(double[][] a, doubled x)

doubl e[] multi ply (doubl e[] x, doubled d a)

vector dotproduct

matrix-matrixproduct

transpose

matrix-vector product

vector-matrix product

(See Section 1.4.) As a test client, use thefollowing code, which performs the samecalculation as Markov (Program 1.6.3).


int T = Integer.parselnt(args[0]);double[][] p = StdArraylO.readDouble2D();double[] rank = new double[p.length];rank[0] = 1.0;for (int t = 0; t < T; t++)

rank = Matrix.multiply(rank, p);StdArraylO.print(rank);


Mathematicians and scientistsuse mature libraries or special-purposematrix-processing languages for such tasks (see theContext section attheendof this book forsome details). See the booksite for information on using such libraries.

2.2.12 Write a Matrix client that implements the version of Markov describedin Section 1.6 but is based on squaring the matrix, insteadof iterating the vector-matrix multiplication.

2.2.13 Rewrite RandomSurfer (Program 1.6.2) using the StdArraylO and StdRandom libraries.

Partial solution.

double[][] p = StdArraylO.readDouble2D();int page = 0; // Start at page 0.int[] freq = new int[N];for (int t = 0; t < T; t++)

{page = StdRandom.discrete(p[page]);freq[page]++;

}

2.2.14 Add a method exp() to StdRandom that takes an argument Xand returns arandom numberfrom theexponential distribution with rate X. Hint Ifx isarandomnumber uniformly distributed between 0 and 1, then -In xl Xisarandom numberfrom the exponentialdistributionwith rate X.


i:9^^im^SSKi^^

2.2.15 Sicherman dice. Suppose that you have two six-sided dice, one with faceslabeled 1,3,4,5,6, and 8 and the other with faces labeled 1,2,2, 3,3, and 4. Compare the probabilities of occurrence of each of the valuesof the sum ofthe dice withthose for a standard pair of dice. Use StdRandom and StdStats.

2.2.16 Craps. The following are the rulesfor apass bet in the game of craps. Rolltwo six-sided dice, and let x be their sum.

• If x is 7 or 11,you win.• If x is 2,3, or 12,you lose.

Otherwise, repeatedly roll the two dice until their sum is either x or 7.• If their sum is x, you win.• If their sum is 7,you lose.

Writea modular program to estimate the probability of winninga passbet. Modifyyour program to handle loaded dice, where the probability of a die landing on1 is taken from the command line, the probability of landing on 6 is 1/6 minusthat probability, and 2-5 are assumed equally likely. Hint: Use StdRandom.dis-crete().

2.2.17 Dynamic histogram. Suppose that the standardinput streamis a sequenceof double values. Writea programthat takes an integer Nand two double values 1and r from the command line and uses StdStats to plot a histogramof the countof the numbers in the standard input stream that fall in each of the N intervalsdefined by dividing (/, r) into N equal-sized intervals. Use your program to addcodeto your solution to Exercise 2.2.3 to plot a histogramof the distribution of thenumbers produced by eachmethod, takingNfrom the command line.

2.2.18 Tukey plot. A Tukey plot is a data visualization that generalizes a histogram, and is appropriate for use when each integer in a given range is associatedwith a setofyvalues. Foreachinteger in the range, wecomputethe mean,standarddeviation, 10th percentile, and 90th percentile of all the associated y values; drawa vertical line with x-coordinate i running from the 10th percentiley value to the90th percentile/value; and then drawa thin rectangle centeredon the line that runsfrom one standard deviation below the mean to one standard deviation above the

mean. Suppose that the standard input stream is a sequence of pairs of numbers

251


wherethe firstnumber in eachpair isan i nt and the seconda doubl e value.WriteaStdStats and StdDraw client that takesan integer N from the command line and,assumingthat all the i nt values on the input stream are between 0 and N-l, usesStdDrawto make a Tukeyplot of the data.

2.2.19 IFS. Experimentwith variousinputs to IFS to createpatterns of your owndesignlike the Sierpinski triangle, the Barnsley fern, or the other examples in thetable in the text.You might begin by experimentingwith minor modifications tothe given inputs.

2.2.20 IFS matrix implementation. Writea version of IFS that uses Mat ri x.mul-t i pi y0 (seeExercise 2.2.11)instead of the equations that compute the new valuesof xO and yO.

2.2.21 Stress test. Develop a client that does stress testing for StdStats. Workwith a classmate, with one person writing code and the other testing it.

2.2.22 Gambler's ruin. Develop a StdRandom client to study the gambler's ruinproblem (see Program 1.3.8 and Exercises 1.3.21-24. Note: Defining a static method for the experiment is more difficult than for Bernoulli because you cannotreturn two values.

2.2.23 Libraryforproperties ofintegers. Develop a librarybasedon the functionsthat wehaveconsideredin this book for computing properties of integers. Includefunctions for determining whether a given integer is prime; whether two integersare relatively prime;computingall the factors of a given integer; the greatest common divisor and least common multiple of two integers; Euler's totient function(Exercise 2.1.26); and anyother functions that you think might be useful. Includeoverloaded implementations for 1ong values. Create an API, a clientthat performsstresstesting,and clients that solve several of the exercises earlier in this book.

2.2.24 Voting machines. Develop a StdRandom client (with appropriate staticmethods of its own) to study the following problem: Suppose that in a population of 100 million voters, 51% vote for candidate A and 49% vote for candidateB.However, the voting machinesare prone to make mistakes, and 5% of the time


they produce the wrong answer. Assuming the errors are made independently andat random, is a 5% error rate enough to invalidate the results of a close election?What error rate can be tolerated?

2.2.25 Poker analysis. Write a StdRandom and StdStats client (with appropriatestaticmethods of its own) to estimatethe probabilities of gettingone pair, two pair,three of a kind, a full house, and a flush in a five-card poker hand via simulation.Divideyour program into appropriate staticmethods and defendyour design decisions. Extra credit: Add straight and straight flush to the list of possibilities.

2.2.26 Music library Develop a library based on the functions in PIayThatTune(Program 2.1.4)that you can use to write clientprograms to createand manipulatesongs.

2.2.27 Animated plots. Write a program that takes a command-line argument Mand producesabar graph of the Mmost recentdouble values on standard input. Usethe same animation technique that we used for BouncingBall (Program 1.5.6):erase,redraw, show, and wait briefly. Eachtime your program reads a new number,it should redraw the whole graph. Since most of the picture does not changeas itis redrawn slightlyto the left, your program will produce the effectof a fixed-sizewindowdynamically slidingoverthe input values. Use your program to plot a hugetime-variant data file,such as stock prices.

2.2.28 Array plot library. Develop your own plot methods that improve uponthose in StdStats. Becreative! Tryto makea plottinglibrarythat you think willbeuseful for some application in the future.

253


23 Recursion

The ideaof calling one function from another immediately suggeststhe possibilityof a function calling itself The function-call mechanism in Javaand most modernprogramming languages supports this possibility, which is known as recursion. Inthis section, we will study examplesof elegant and efficient recursive solutions toavariety ofproblems. Once you get used 23A Euclid>s %>rithm • 259x . ' r .„ - ' &. . 2.3.2 Towers ofHanoi 262to theidea, you will see thatrecursion isa ?33 G d 267powerful general-purpose programming 2^4 Recursive graphic! ........ .269technique with many attractive proper- 2.3.5 Brownian bridge 271ties. It is a fundamental tool that we use Programs in this section

often in this book. Recursive

programs are often more compact and easier to understand than their nonrecursive counterparts. Fewprogrammers become sufficientlycomfortable with recursion to use it ineverydaycode, but solving a problem with an elegantly crafted recursiveprogram is a satisfying experiencethat is certainly accessible to everyprogrammer (even you!).

Recursion is much more than a programming technique. In manysettings, it is a useful wayto describe the natural world. For example, the

r. x , j, recursive tree (to the left) resembles a real tree, and has a natural recur-of the natural world . . v ' .

sive description. Many, many phenomena are well-explained by recursivemodels. In particular, recursion plays a central role in computer science.

It provides a simple computational model that embraces everything that can becomputed with any computer; it helps us to organize and to analyzeprograms; andit is the key to numerous critically important computational applications, rangingfrom combinatorial search to tree data structures that support information processingto the Fast Fourier Transform for signalprocessing.

One important reason to embrace recursion is that it provides a straightforward way to build simple mathematical models that we can use to prove importantfacts about our programs. The proof technique that we use to do so is known asmathematical induction. Generally, we avoid going into the details of mathematicalproofs in this book, but you will see in this section that it is worthwhile to make theeffort to convince yourself that recursive programs have the intended effect.

I®

Si

til

11

2.3 Recursion

Mi^^^Î;';<I2m^&j±sii£&si. '•^ÎM^Ms^Mî\


2.3 Recursion

The ideaohcalling one wnction from another immediately suggeststhe possibilityof a function callingitself.The function-callmechanism in Javaand most modernprogramminglanguagessupports this possibility,which is known as recursion. Inthis section,we will study examplesof elegant and efficient recursivesolutions toa varietyof problems.Once you get usedto the idea,you willseethat recursionisapowerful general-purposeprogrammingtechnique with many attractive properties. It is a fundamental tool that we use

often in this book. Recursive

programs arc often more compact and easierto understand than their nonrecursivecounterparts.Fewprogrammersbecome sufficientlycomfortablewith recursionto use it ineverydaycode, but solvinga problemwith an elegantlycraftedrecursive

satisfyingexperiencethat iscertainlyaccessible to everyprogrammer (even you!).

Recursionis much more than a programmingtechnique. In manysettings,it isa usefulwayto describethe naturalworld. Forexample,the

' '/""' recursive tree (tothe left) resembles areal tree, and has anatural recursivedescription. Many,many phenomena arewell-explainedby recursivemodels. In particular,recursion playsa centralrole in computer science.

It provides a simple computational model that embraces everything that can becomputedwith anycomputer;it helpsus to organizeandto analyzeprograms; andit is the key to numerouscriticallyimportant computationalapplications, rangingfrom combinatorialsearchto tree datastructuresthat support information processingto the FastFourierTransformforsignalprocessing.

One important reasonto embracerecursionis that it providesa straightforwardwayto build simplemathematicalmodelsthatwecanuseto proveimportantfactsabout our programs.The proof technique that we use to do so is known asmathematical induction. Generally, weavoidgoinginto thedetailsof mathematicalproofs in this book, but you will seein this section that it isworthwhileto make theeffort toconvincejraurscjfthat recursive programs have theintended effect.

23J TowmofHanoi. ..Z3J Graycode.23.4 Rcctmivcgraphics..

Proglottis in adsstetson

ylilidizzoqarilzlzagguzvjalsibammitarilons taaA Morrovim hmoduluad to A3aihhTrnabomtzom bno svsl ni mzinsfbam Um-noiftnu) arfT\latti gnilh» noittnin*sloni .nointnai zs nworolzi rbiriw,xliIidizzoqzirfiziioqquz zagsugnslgnimmsigoiq

-lalo zalqmsxaybutz Itiwaw.noilaazziritol znobuloz aviaimai inaiorfb bne insgabazu lag uov,aanO.zmaldoiq 1o ylahsv ss ainoiziusai isril aazlliwuov,,sabiad)otgnimms-igoiq azoqiuq-lsianag luhawoq•taqoiq aviftsilts ynem riliw aupintbalazu aw Isril loo) Islnamsbnul e zi II job

avirumJI jlood ziril ni nafto

-rnoD aiom naflo aic zmsigoiqwaH .zmqialnuoa aviziroainonliariinsrflbnsiziabnu o) laizoabns lacqni ti azuot noiziuaairiliwaldsnolmco ybnabfftuz amcoadziammsigoiqaviziiroi battels xbnsgab n* riliwmaldoiq s gnivloatud ,abro YakY131"-oiq \iava ot aldizzasasYJnistiaazilsdt asnahaqxagnivlzbBZs zi msigoiq

.(luov.nava) lammsigXnern nl .aupinriaal gnirnmsigoiq s nerflaiom (bum zi noizimaflaril.alqmBxaicfl .bhow Ismlsn ariladrrazab ol yew liiiazub zi Ji.zgniltaz-iirni Isiulsn bzbiI bns.aailIsai bzaldmazai (flal aril ol)aailavizimai ' |"1"aviziuaaiyd banislqxa-Ilawais BnamonariqYnsm .ynsM .nobqmzab aviz.asnabz latuqnio? ni aloi isitnaa s zyslq noizunai .islmbisq ni .zbbomad nsa teril gnirirfiava zaacidmaIsril bborn Isnobsluqrnco alqmh e zabivoiq Hbns ;zmsigoiq aliens ol bn6axinsgiool zu zqlarili ;ialuqni03yns riliwbaluqmoagnignsi .znoitsailqqsisnoilstuqmo} instioqmi xllsabrn zuoiamun ol v»l arilzi li•oiq noilBrmoIni lioqquz isril zaiulsinlz slsb aail ol ibisaz Isholsnidmco moil

.gnizzaxnqIsngizid) miotansiT lahuoHIttrlarilol gnizzas-lobrigisilz s zabivoiqli isril zi noiziuoaiaasidma ol nozsai Inslioqmi anOtnclioqmi avoiqol azunsoawlBrilzbbom IsahsmarilBm alqmizbliud ol ysw biBwzbnwoml zi oaob ol azu awIsrilaupimballooiq arIT.zmsigoiq mo luods zlss)Isaiismarilsmlo zlislabarilolni gniogbiovs aw.ylknanaO.notouWt \tk»tttmamt>marila)(smol aliriwrinowzi li isril nobaazzirilni aazlliw ooy lud ,)loodtiril ni atomq

.taafiababnalni arilavsrizmsigoiq aviziusai Isrilllaziuoy aanivnos ol ndfla

lonsHlomwoT S.tSaixw^nD e.C£

....... .nlffqoissWniiMfl *.t£sgWidntinvraiS Z.IS

notott itth ni immônfl

A recursive image

255


Your first recursive program The Hel 1oWorl d for recursion (the first recursiveprogram that most programmers implement) is the factorial function, definedfor positive integers AT by the equation

N\=NX (N-l) X (N-2) X ... X 2 X 1

In other words, N! is the product of the positive integers less than or equal to N.Now,N! is easyto compute with a for loop, but an even easier method is to use thefollowing recursive function:

public static long factorial(int N){

if (N == 1) return 1;return N * factorial(N-l);

}

This static method calls itself.The implementation clearly produces the desired effect. You can persuade yourself that it does so by noting that f actori al () returns1 = 1!when AT is 1 and that if it properly computes the value

(N-l)! - (N-l) X (N-2) X ... X 2 X 1

then it properly computes the value

. N\=NX (N-l)!

= N X (N-l) X (N-2) X ... X 2 X 1

Tocompute f acto ri al ( 5), the recursivemethod multiplies 5by f actori al (4); to compute f actori al (4),it multiplies 4 by factorial (3); and so forth. Thisprocess is repeated until facto ri al (1), which directly returns the value 1. We can trace this computationin precisely the same way that we trace any sequenceof function calls.Since we treat all of the calls as beingindependent copies of the code, the fact that they arerecursive is immaterial.

Our factorial () implementation exhibits thetwo main components that are required for every recursive function. The base casereturns a value without making any subsequent recursive calls. It does this for oneor more special input values for which the function can be evaluated without re-

factorial(5)factorial (4)

factorial (3)factorial (2)

factorial (1)return 1

return 2*1 =

return 3*2 = 6

return 4*6 = 24

return 5*24 = 120

Function call tracefor factorial

2.3 Recursion 257

cursion. For factorial (), the base case is N = 1.The reduction step is the centralpart of a recursive function. It relates the function at one (or more) inputs to thefunction evaluatedat one (or more) other inputs. For factorial 0, the reductionstep is N * factorial (N-l). All recursive functions must havethese two components. Furthermore, the sequence of parametervalues must converge to the base case.For facto ri al (), the valueof N decreases by one for each call, so the sequence of argumentvalues converges to the base case JV = 1.

Tiny programs such as facto rial() are perhaps slightlymore clear if we put the reduction step in an el se clause. However,adopting this convention for every recursive program would unnecessarily complicate larger programs because it would involveputting most of the code (for the reduction step) within bracesafter the el se. Instead, we adopt the conventionof always puttingthe base case as the first statement, ending with a return, andthen devoting the rest of the code to the reduction step.

The factorial () implementation itself is not particularlyuseful in practice because N! growsso quicklythat the multiplication will overflow and produce incorrect answers for N > 20. Butthe same technique is effective for computing all sorts of functions. For example, the recursive function


if (N == 1) return 1.0;return H(N-l) + 1.0/N;

}

is an effective method for computing the Harmonic numbers (see Program 1.3.5)when JV is small, based on the following equations:

HN= 1 + 1/2 + ... + 1/N

= (l + l/2 + ... + l/(N-l)) + l/N = H^ + l/N

2 2

3 6

4 24

5 120

6 720

7 5040

8 40320

9 362880

10 3628800

11 39916800

12 479001600

13 6227020800

14 87178291200

15 1307674368000

16 20922789888000

17 355687428096000

18 6402373705728000

19 121645100408832000

20 2432902008176640000

Values of N\ in long

Indeed, this same approach is effective for computing, with only a fewlines of code,the value of any discrete sum for which you have a compact formula. Recursiveprograms like these are just loops in disguise, but recursion can help us better understand this sort of computation.


Mathematical induction Recursive programming is directly relatedto mathematical induction, a technique for proving facts about discrete functions.

Proving that a statement involving an integer JV is true for infinitely manyvalues of JVbymathematical induction involvesthe following two steps:

• The base case: prove the statement true for some specificvalue or values ofJV (usually 1).

• The induction step (the central part of the proof): assume the statementto be true for all positive integers less than JV, then use that fact to prove ittrue for JV.

Such a proof sufficesto show that the statement is true for all JV: we can start at thebase case, and use our proof to establish that the statement is true for each largervalue of JV, one by one.

Everyone'sfirst induction proof is to demonstrate that the sum ofthe positiveintegers less than or equal to JVis givenby the formula JV(JV+l)/2. That is, we wishto prove that the following equation is valid for all JV > 1:

1+2 + 3 ... + (JV-1)+JV = JV(N+l)/2The equation is certainly true for JV = 1 (base case). If we assume it to be true for allintegers less than JV, then, in particular, it is true for JV— 1, so

1 + 2 + 3 ... +(JV-1) = (JV-l)JV/2and we can add JV to both sides of this equation and simplify to get the desiredequation (induction step).

Every time we write a recursive program, we need mathematical induction tobe convinced that the program has the desired effect. The correspondence betweeninduction and recursion is self-evident. The difference in nomenclature indicates

a difference in outlook: in a recursive program, our outlook is to get a computation done by reducing to a smaller problem, so we use the term reduction step; inan induction proof, our outlook is to establish the truth of the statement for largerproblems, so we use the term induction step.

When wewrite recursiveprograms we usuallydo not write down a full formalproof that they produce the desired result, but we are always dependent upon theexistence of such a proof. We do often appeal to an informal induction proof toconvince ourselves that a recursiveprogram operates as expected. For example, wejust discussedan informal proof to become convinced that f actori al () computesthe product of the positive integers less than or equal to JV.

2.3 Recursion 259

m^m^m^mMmmMm^^mmmiM^Mmmmmmmmm

Program 2.3.1 Euclid's algorithm

public class Euclid{

public static int gcd(int p, int q){

if (q == 0) return p;return gcd(q, p % q);

}public static void main(String[] args){

int p = Integer.parselnt(args[0]);int q = Integer.parselnt(args[l]);int d = gcd(p, q);StdOut.println(d);

}}

P, q

d

arguments

greatest common divisor

This program prints out thegreatest common divisor of its two command-line arguments, usinga recursive implementation of Euclid's algorithm.

^S™ %java Euclid 1440 40824

% Java Euclid 314159 2718281

"^^sî^^^^^^^^^^î^î^^PÎP^^

Euclid's algorithm Thegreatest common divisor (gcd) of two positive integersis the largestinteger that dividesevenlyinto both of them. For example,the greatestcommon divisor of 102 and 68 is 34 since both 102and 68 are multiples of 34, butno integer larger than 34 divides evenly into 102 and 68. You may recall learningabout the greatest common divisor when you learned to reduce fractions. For example, we can simplify68/102 to 2/3 by dividingboth numerator and denominatorby 34, their gcd. Finding the gcd of huge numbers is an important problem thatarises in many commercial applications, including the famous RSAcryptosystem.

We can efficientlycompute the gcd using the following property, which holdsfor positive integers p and q:


Ifp>q, thegcdofp and q is thesameas thegcdof q andp %q.

To convinceyourself of this fact, first note that the gcd ofp and q is the same as thegcd of q and p—qy because a number divides both p and q if and only if it dividesboth qandp—q. Bythe sameargument,qandp—2q, qandp—3q, and so forth have

the same gcd,and one wayto compute p % q is to subtract q from

9Cd Ccd C4084°216) Puntil 8ettin8 anumber less than <?•gcd(2l6, 24) The static method gcd() in Euclid (Program 2.3.1) is a

gcd (192, 24) compact recursive function whosereduction step isbased on thisgc return 24 property. The base case is when qis 0, with gcd (p, 0) = p. To seereturn 24 that the reduction step converges to the base case, observe that

return 24 fae secondinput strictlydecreases in each recursive callsince p %return 24 .

return 24 9 < q. If p <^>the first recursivecall switches the arguments. InFunction call trace for qcd ^act> ^e second input decreases by atleast a factor oftwo for ev

ery second recursive call,so the sequence of inputs quickly converges to the base case (see Exercise 2.3.11). This recursive solu

tion to the problem of computing the greatest common divisor is known as Euclid'salgorithm and is one of the oldest known algorithms—it is over 2,000years old.

Towers of Hanoi No discussion of recursion would be complete without theancient towers ofHanoiproblem. In this problem, we have three poles and n discsthat fit onto the poles.The discsdiffer in sizeand are initially stacked on one of thepoles,in order from largest (discn) at the bottom to smallest (disc 1) at the top. Thetask is to move all n discs to another pole, while obeying the following rules:

• Move only one disc at a time.• Never place a larger disc on a smaller one.

One legend says that the world will end when a certain group of monks accomplishes this task in a temple with 64 golden discs on three diamond needles. Buthow can the monks accomplish the task at all, playing by the rules?

Tosolvethe problem, our goal is to issue a sequence of instructions for moving the discs. Weassumethat the polesare arranged in a row,and that each instruction to move a disc specifies its number and whether to move it left or right. If adisc is on the left pole, an instruction to move left means to wrap to the right pole;if a disc is on the right pole, an instruction to move right means to wrap to the leftpole. When the discs are all on one pole, there are two possible moves (move thesmallest disc left or right); otherwise, there are three possible moves (move thesmallest disc left or right, or make the one legalmove involving the other two poles).

23 Recursion

Choosing among these possibilities on each move to achieve the goal is a challengethat requires a plan. Recursion provides just the plan that we need, based on thefollowingidea: first we move the top n—\ discs to an empty pole, then we move thelargest disc to the other empty pole (where it does not interfere with the smaller ones), and then we complete the job bymoving the n—\ discs onto the largest disc.

TowersOfHanoi (Program 2.3.2) is a direct implementation of this strategy. It reads in a command-line argument n and prints out the solution to the Towers of Hanoiproblem on n discs. The recursive static method moves ()prints the sequence of moves to move the stack of discs tothe left (if the argument left is true) or to the right (if1eft is fal se). It does so exactly according to the plan justdescribed.

startposition

261

moven-1 discsto theright (recursively)

Function call trees To better understand the behav

ior of modular programs that have multiple recursive calls(such as TowersOfHanoi), we use a visual representationknown as afunction call tree. Specifically, we represent eachmethod call as a tree node, depicted as a circle labeled withthe values of the arguments for that call. Below each treenode, we draw the tree nodes corresponding to each call inthat use of the method (in order from left to right) and linesconnecting to them. This diagram contains all the information we need to understand the behavior of the program. It contains a tree node for each method call.

We can use function call trees to understand the behavior of any modularprogram, but they are particularly useful in exposing the behavior of recursive

programs. For example, the treecorresponding to a call to move()in TowersOfHanoi is easy to construct. Start by drawing a treenode labeled with the values of

the command-line arguments.The first argument is the numberof discs in the pile to be moved

Function call tree for moves (4, true) in TowersOfHanoi (and the label of the disc to actu-

movelargest discleft (wrapto rightmost)

moven-1 discsto theright (recursively)

Recursive planfor towers ofHanoi


Program 2.3.2 TowersofHanoi

public class TowersOfHanoi{

public static void moves(int n, boolean left){

if (n == 0) return;moves(n-1, !left);if (left) StdOut.println(n + " left");else StdOut.println(n + " right");moves(n-1, !left);

}public static void main(String[] args){ // Read n, print moves to move n discs left.

int n = Integer.parselnt(args[0]);moves(n, true);

}

}

n

left

number of discs

direction to move pile I

The recursive method moves() prints the moves needed to move n discs to the left (if left istrue) or to theright(if~\ eft is fal se).

% Java TowersOfHanoi1 right2 left

1 right

% Java TowersOfHanoi1 left

2 right1 left

3 left

1 left

2 right1 left

rightleft

rightrightri ghtleft

rightleft

rightleft

rightrightrightleft

right

i

^^^^^^P^^^^^^^^^^^^roSS?^^ ^^^|^SPSI?SiSSiSf^^Wm^^^W^^^^'-mmm*

2.3 Recursion

ally be moved); the second is the direction to move the pile. For clarity, we depictthe direction (a bool ean value) as an arrow that points left or right, since that isour interpretation of the value—the direction to movethe piece. Then draw two tree nodes below with thenumber of discs decremented by 1 and the directionswitched, and continue doing so until only nodes withlabels corresponding to a first argument value 1 haveno nodes below them. These nodes correspond to callson moves () that do not lead to further recursive calls.

Take a moment to study the function call treedepicted earlier in this section and to compare it withthe corresponding function call trace depicted at right.When you do so, you will see that the recursion tree isjust a compact representation of the trace. In particular, reading the node labels from left to right gives themoves needed to solve the problem.

Moreover,when you study the tree, you probablynotice several patterns, including the following two:

• Alternate moves involve the smallest disc.

• That disc alwaysmoves in the same direction.These observations are relevant because they give asolution to the problem that does not require recursion (or even a computer): every other move involvesthe smallest disc (including the first and last), and eachintervening move is the only legal move at the timenot involving the smallest disc. We can prove that thismethod produces the same outcome as the recursiveprogram, using induction. Having started centuries agowithout the benefit of a computer, perhaps our monksare using this method.

Trees are relevant and important in understanding recursion because the tree is the quintessentialrecursive object. As an abstract mathematical model,trees play an essential role in many applications, and inChapter 4, we will consider the use of trees as a computational model to structuredata for efficient processing.

moves(4, true)moves(3, false)

moves(2, true)moves(1, false)

1 right

A

263

2 left

moves(1, false)1 right AH

3 rightmoves(2, true)

moves(1, false)1 right

2 left


4 left

moves(3, false)moves(2, true)


2 left


3 rightmoves(2, true)


2 left

moves(11

false)right

XA 13 discs moved right

1 iXdisc4 movedleft

1 ±XUXux

1U

1 1*3 discsmovedright

Function call trace for moves(4, true)


Exponential time One advantage of using recursion is that often we can develop mathematical models that allowus to prove important facts about the behavior of recursive programs. For the towers of Hanoi, we can estimate the amount oftime until the end of the world (assuming that the legend is true). This exercise isimportant not just because it tells us that the end of the world is quite far off (evenif the legend is true), but also because it provides insight that can help us avoidwriting programs that will not finish until then.

For the towers of Hanoi, the mathematical model is simple: if we define thefunction T(n) to be the number of move directives issued by TowersOf-Hanoi to move n discs from one peg to another, then the recursive codeimmediately implies that T(n)must satisfythe following equation: oo, 2*>) -

T(n) = 2 T(n-1) 4- 1 for n > 1, with T(l) = 1Such an equation is known in discrete mathematics as a recurrence relation. Recurrence relations naturally arise in the study of recursive programs.Wecan often use them to derivea closed-form expression for thequantity of interest. For T(n), you may havealreadyguessedfrom the initial values 7X1) = 1, T(2) = 3, T(3), = 7, and T(4) = 15 that T(n) = 2n - 1.The recurrence relation provides a wayto prove this to be true, by mathematical induction:

• Base case: T(l) = 2n - 1 = 1• Induction step: if T(n-1)= 2""1 - 1, T(n) = 2 (2n~l - I) + 1 = 2" - 1

Therefore,by induction, T(ri) = 2" —1 for all n > 0. The minimum possible number of moves also satisfies the same recurrence (see Exercise2.3.9).

Knowing the value of T(n),we can estimate the amount of time required toperform all themoves. Ifthemonks move discs attherate ofone xPonen ia

growthper second, it would take more than one week for them to finish a 20-discproblem, more than 31 years to finish a 30-disc problem, and more than348centuries for them to finish a 40-disc problem (assumingthat they do not makea mistake). The 64-disc problem would take more than 1.4 million centuries. Theend of the world is likelyto be evenfurther off than that because those monks presumablynever havehad the benefitof using Program 2.3.2, and might not be ableto move the discsso rapidly or to figure out so quicklywhich disc to move next.

Even computers are no match for exponential growth. A computer that cando a billion operations per secondwillstilltake centuries to do 264 operations, andno computer will ever do 21000 operations, say. The lesson is profound: with recur-

2.3 Recursion 265

sion, you can easily write simple short programs that take exponential time, butthey simply will not run to completion when you try to run them for large n. Novices are often skeptical of this basic fact, so it is worth your while to pause now tothink about it. To convince yourself that it is true, take the print statements out ofTowersOfHanoi and run it for increasing values of n starting at 20. You can easilyverifythat each time you increasethe valueof nby 1,the running time doubles, andyou will quickly lose patience waiting for it to finish. If you wait for an hour forsome value of n, you will wait more than a day for rc+5, more than a month forn+10, and more than a century for n+20 (no one has thatmuch patience). Yourcomputer is just not fast enough to run everyshort Javaprogram that you write, nomatter how simple the program might seem! Beware ofprograms thatmight requireexponential time.

We are often interested in predicting the running time of our programs. InSection 4.1, we will discuss the use of the same process that we just used to helpestimate the running time of other programs.

Gray codes The towers of Hanoi problem is no toy. It is intimately related tobasicalgorithms for manipulatingnumbersand discrete objects. Asan example, weconsider Gray codes, a mathematicalabstractionwith numerous applications.

The playwright Samuel Beckett, perhaps best known for Waiting for Godot,wrote a playcalled Quad that had the following property: starting with an emptystage, characters enter and exit one at a time so that each subset of characters onthe stage appearsexactly once.Howdid Beckett generate the stagedirections for thisplay? code subset

One way to represent asubset ofndiscrete objects is to use a o 0 0 1 "T*'string of n bits. For Beckett's problem, we use a 4-bit string, with 0 0 l l 2 1 enter 2bits numbered from right to left and abit value of 1indicating the q110 322 enter 3character onstage. For example, the string 0 10 1 corresponds 0 1 l 1 3 2 1 enter lto the scene with characters 3and 1onstage. This representation q l 0o ^ exit ?gives a quick proof of a basic fact: the number different subsets ofn noo 4 3 enter 4objects isexactly 2". Quad has four characters, so thereare 24 = 16 } } ? } A3,1, enter x

' '_ _. , ,. 11114321 enter 2different scenes. Our task is to generate the stage directions, l l l o 4 3 2 exit 1

An ra-bit Gray code is a list of the 2" different rc-bit binary } 5 } ° 4->2 exit 3, iii . i i. i.«- • .i i. 1011 421 enter 1

numbers such that each entry in the list differs in precisely one bit i o 0 1 4 1 exit 2from its predecessor. Gray codes directlyapply to Beckett's prob- 10 0 0 4 exit llem becausechangingthe valueof a bit from 0 to 1corresponds to Gray code representations

enter 1

266

2-bit

3-bit


a character entering the subset onstage; changing a bit from 1 to 0 corresponds toa character exiting the subset.

How do we generate a Gray code? A recursiveplan that is very similar to theone that we used for the towers of Hanoi problem is effective. The n-bit binary-reflected Gray code is defined recursively as follows:

• The (n— 1) bit code, with 0 prepended to each word, followed by• The (n—1) bit code in reverse order, with 1 prepended to each word

The 0-bit code is defined to be null, so the 1-bit code is 0 followed by 1. From thisrecursive definition, we can verifyby induction that the n-bit binary reflected Gray

code has the required property: adjacent codewords differ in one bit position. It is true by the inductive hypothesis,exceptpossiblyfor the last codeword in the first halfand the first codeword in the second half: this pair differsonly in their first bit.

The recursive definition leads, after some carefulthought, to the implementation in Beckett (Program2.3.3) for printing out Beckett's stage directions. Thisprogram is remarkably similar to TowersOfHanoi. Indeed, except for nomenclature, the only difference isin the values of the second arguments in the recursivecalls!

As with the directions in TowersOfHanoi, the en

ter and exit directions are redundant in Beckett, since

exit is issued only when an actor is onstage, and enteris issued only when an actor is not onstage. Indeed, bothBeckett and TowersOfHanoi directly involve the rulerfunction that we considered in one of our first programs

(Program 1.2.1).Without the redundant instructions, they both implement a simple recursive function that could allow Rul er to print out the values of the rulerfunction for any value givenas a command-line argument.

Gray codes have many applications, ranging from analog-to-digital converters to experimental design.They havebeen used in pulse code communication, theminimization of logic circuits, and hypercube architectures, and were even proposed to organize books on library shelves.

1-bit code 3-bit code

1 I0 0 4-bit 0 0 0 00 1 0 0 0 11 1 0 0 11

1 0 \ 0 0 101-bit code 0 110(reversed) 0 111

2-bit code 0 10 1

\ 0

1

10 0

0 0 0 10 0

0 0 1 1 10 1

0 11 1 111

0 1 0 1

1

110

0 101 1 0

1 11 1 0 11

1 0 1 1 0 0 1

1 0 0 1 0 0 0

t t2-bit code 3-bit code

0 evtrscd) (reversed)

2-, 3-, and 4-bit Gray codes

2.3 Recursion 267

ISA

ill

u$

m

mIII

r

Si

Program 2.3.3 Gray code

public class Beckett{

public static void moves(int n, boolean enter){

if (n == 0) return;moves(n-l, true);if Center) StdOut.println("enter " + n);else StdOut.println("exit " + n);moves(n-1, false);

}

}


int n = Integer.parselnt(args[0]);moves(n, true);

}

n

enter

number of characters

stagedirection

^m$&mtMmm^mmmw*

This recursive program gives Beckett's stage instructions (the bitpositions that change in abinary-reflected Gray code). The bit position that changes isprecisely described by the rulerfunction, and(ofcourse) each character alternately enters and exits.

268

order 1

order 2


Recursive graphics Simple recursive drawing schemes can lead to picturesthat are remarkably intricate. Recursive drawings not only relate to numerous applications,but they also provide an appealingplatform for developinga better understanding of properties of recursiveprograms, because we can watch the processof a recursive figure taking shape.

As a first simple example, consider Htree (Program 2.3.4), which, given acommand-line argument n,draws an H-tree oforder n,defined as follows: The basecase is to draw nothing for n = 0. The reduction step is to draw, within the unitsquare

• three lines in the shape of the letter H• four H-trees of order n—\, one connected to each tip of the H

with the additional provisos that the H-trees of order n— 1 are halved in size andcentered in the four quadrants of the square.

Drawings like these have many practical applications. For example,consider a cable company that needs to run cable to all of the homes distributed throughout its region. A reasonable strategy is to use an H-tree to getthe signal to a suitable number of centers distributed throughout the region,then run cablesconnecting each home to the nearest center.The same problem is faced by computer designers who want to distribute power or signalthroughout an integrated circuit chip.

Though every drawing is in a fixed-size window, H-trees certainly exhibit exponential growth. An H-tree of order n connects 4" centers, so youwould be trying to plot more than a million lines with n = 10, more than abillion with n = 15, and the program will certainly not finish the drawingwith n = 30.

If you take a moment to run Htree on your computer for a drawingthat takes a minute or so to complete,you will, just by watching the drawingprogress, have the opportunity to gain substantial insight into the nature ofrecursive programs, because you can see the order in which the H figuresappear and how they form into H-trees. An even more instructive exercise,which derives from the fact that the same drawing results no matter in whatorder the recursive draw() calls and the StdDraw. 1i ne() calls appear, is to

observe the effect of rearranging the order of these calls on the order in which thelines appear in the emerging drawing (see Exercise2.3.14).

H M

H Horder 3

hHljl MMhTh H HM|M m|mHH HH

H-trees

2.3 Recursion 269

mimmm^^^^^^mm^^^^^^mmm^^mIP

f&

m

H

Program 2.3.4 Recursive graphics

public class Htree{

public static void draw(int n, double sz, double x, double y){ // Draw an H-tree centered at x, y

// of depth n and size sz.if (n == 0) return;double xO = x - sz/2, xl = x + sz/2;double yO = y - sz/2, yl = y + sz/2;StdDraw.line(xO, y, xl, y);StdDraw.line(xO, yO, xO, yl);StdDraw.line(xl, yO, xl, yl);draw(n-l, sz/2, xO, yO);draw(n-l, sz/2, xO, yl);draw(n-l, sz/2, xl, yO);draw(n-l, sz/2, xl, yl);

}


int n = Integer.parselnt(args[0]);draw(n, .5, .5, .5);

}

fro'/i)

This recursive program draws three lines in the shape ofthe letter H that connect the center (x,y) ofthe square with the centers ofthefour quadrants, then calls itselfforeach ofthe quadrants,using an integer argument tocontrol thedepth of the recursion.

M M M M

H

H

H H

H H

H

H

H H H H

^SBSHi W$$M$i$2W&%8$*\!%;

\

hnlji rp rp rp rp rp rpHJH HfH HJH rW\

H[H hrjjM

Hhrl MM

hIh HJH

MjhH

HlHrri Jti \t\ Jti rr\ hrl rH hp

HH HH HH HH

^^^^^^K^*^R^fSW^^^^^^^e9

270

random

displacement 8


Brownian bridge An H-tree is a simpleexampleof afractal: a geometric shapethat can be divided into parts, eachof which is (approximately) a reduced-size copyof the original. Fractalsare easyto produce with recursiveprograms, although scientists,mathematicians, and programmers study them from many different pointsof view. We have alreadyencountered fractals several times in this book—for example, IFS (Program 2.2.3).

The study of fractals plays an important and lasting role in artistic expression,economic analysis and scientific discovery. Artists and scientists use them to buildcompactmodelsof complexshapesthat arisein nature and resistdescription usingconventionalgeometry, such as clouds,plants, mountains, riverbeds, human skin,and many others. Economists also use fractals to model function graphs of economic indicators.

Fractional Brownian motion is a mathematical model for creating realisticfractal models for many naturally rugged shapes. It is used in computational finance and in the study of many natural phenomena, including ocean flows and

nerve membranes. Computing the exact fractals specifiedbythe model can be a difficult challenge,but it is not difficultto compute approximations with recursive programs. Weconsider one simple example here; you can find much moreinformation about the model on the booksite.

Brownian (Program 2.3.5) produces a function graphthat approximates a simple example of fractional Brownianmotion known as a Brownian bridge and closelyrelated functions.You can think of this graph as a random walk that connects two points, from (x0, y0) to (xvyx), controlled by a few

parameters. The implementation is based on the midpoint displacement method,which is a recursive plan for drawingthe plot within the interval [x0, xx]. The basecase (when the size of the interval is smaller than a given tolerance) is to draw astraight line connecting the two endpoints. The reduction case is to dividethe interval into two halves,proceeding as follows:

• Compute the midpoint (xm,ym) of the interval.• Add to the y-coordinateym of the midpoint a random value8, chosen from

the Gaussian distribution with mean 0 and a given variance.• Recur on the subintervals, dividing the variance by a given scaling factor s.

The shape of the curve is controlled by two parameters: the volatility (initial valueof the variance) controls the distance the graph strays from the straight line con-

(^r« +8)

(*o>ro)

Brownian bridge calculation

2.3 Recursion 271

IM

JjMM&i$v&£*

Program 2.3.5 Brownian bridge

public class Brownian{

public static void curve(double xO, double yO,double xl, double yl,double var, double s)

if (xl - xO < .01)

{StdDraw.line(xO, yO, xl, yl);return;

}double xm = (xO + xl) / 2;double ym = (yO + yl) / 2;double delta = StdRandom.gaussian(0, Math.sqrt(var));curve(xO, yO, xm, ym+delta, var/s, s);curve(xm, ym+delta, xl, yl, var/s, s);


double H = Double.parseDouble(args[0]);double s = Math.pow(2, 2*H);curve(0, .5, 1.0, .5, .01, s);

}

Byadding asmall, random Gaussian toa recursiveprogram that would otherwiseplotastraightline, wegetfractal curves. The command-line argument H, known as theHurst exponent, controls thesmoothness of thecurves.

Java Brownian 1

H»»fflliiPiW»


necting the points, and theHurst exponent controls the smoothness of the curve.We denote the Hurst exponent by H and divide the variance by 22H at each recursivelevel.When H is 1/2 (divide by 2 at each level) the curve is a Brownian bridge:a continuous version of the gambler's ruin problem (see Program 1.3.8). When0 <H < 1/2, the displacements tend to increase, resulting in a rougher curve; andwhen 2 > H > 1/2, the displacements tend to decrease, resulting in a smoothercurve. The value 2 —H is known as the fractal dimension of the curve.

The volatility and initial endpoints of the interval have to do with scale andpositioning. The mai n() test client in Browni an allowsyou to experiment with thesmoothness parameter. With values larger than 1/2, you get plots that look something like the horizon in a mountainous landscape; with values smaller than 1/2,you get plots similar to those you might see for the value of a stock index.

Extending the midpoint displacement method to two dimensions producesfractals known as plasma clouds. To draw a rectangular plasma cloud, we use a recursive plan where the base case is to draw a rectangle of a given color and the reduction step is to draw a plasma cloud in each quadrant with colors that are perturbed from the average with a random Gaussian. Using the same volatility andsmoothness controls as in Browni an, we can produce synthetic clouds that are remarkably realistic. Wecan use the same code to produce synthetic terrain, by interpreting the colorvalueas the altitude.Variants of this schemeare widelyused in theentertainment industry to generate background scenery for movies and computergames.

fflPp-

$l|ll-;

* fa":;'•."•"•::;• :>*-f::-•

'••^^M$f%-t *•''... .'•..•"V'

A plasma cloud

2.3 Recursion 273

Pitfalls of recursion By now, you are perhaps persuaded that recursion canhelp you to write compact and elegant programs. Asyou begin to craft your ownrecursive programs, you need to be aware of severalcommon pitfalls that can arise.We have alreadydiscussed one of them in some detail (the running time of yourprogram might grow exponentially). Once identified, these problems are generallynot difficultto overcome, but you willlearn to be verycareful to avoidthem whenwriting recursive programs.

Missing base case. Consider the following recursive function, which is supposedto compute Harmonic numbers, but is missing a base case:


return H(N-l) + 1.0/N;}

If you run a clientthat calls this function, it will repeatedly call itselfand neverreturn, soyour program willneverterminate.You probablyalreadyhaveencounteredinfinite loops, where you invoke your program and nothing happens (or perhapsyou get an unending sequence of lines of output). With infinite recursion, however,the result is different because the system keeps trackof each recursive call (using amechanism that we will discuss in Section 4.3, based on a data structure known asa stack) and eventually runs out of memory tryingto do so. Eventually, Java reportsa StackOverflowError. When you write a recursive program,you should alwaystry to convince yourselfthat it has the desired effect byan informalargument basedon mathematical induction.Doingso might uncover a missing basecase.

No guarantee of convergence. Another common problem is to include within arecursive function a recursive call to solve a subproblem that is not smaller thanthe original problem. For example, the following method will go into an infiniterecursive loop for anyvalue of its argument Nexcept 1:


if (N == 1) return 1.0;return H(N) + 1.0/N;

}


Bugs like this one are easy to spot, but subtle versions of the same problem can beharder to identify.You may find severalexamples in the exercises at the end of thissection.

Excessive memory requirements. If a function calls itself recursively an excessivenumber of times before returning, the memory required by Java to keep track ofthe recursive calls may be prohibitive, resulting in a StackOverflowError. To getan idea of how much memory is involved, run a small set of experiments using ourrecursive program for computing the Harmonic numbers for increasingvalues ofN:


if (N == 1) return 1.0;return H(N-l) + 1.0/N;

}

The point at whichyou get StackOverflowError will give you some idea of howmuch memory Java uses to implement recursion. By contrast, you can run Program 1.3.5 to compute HN for huge N using only a tiny bit of space.

Excessive recomputation. The temptationto write a simple recursive program tosolve a problem must always be temperedby the understanding that a simple program might take exponentialtime (unnecessarily) due to excessive recomputation.This effect is possible even in the simplest recursive programs, and you certainlyneed to learn to avoid it. For example, the Fibonacci sequence

0 1 1 2 3 5 8 13 21 34 55 89 144 233 377 ...

is definedby the recurrenceFn = Fn_x + Fn_2 for n > 2 with JF0 = 0 and Fx = 1.TheFibonacci sequence hasmanyinteresting propertiesand arisein numerous applications. A noviceprogrammer might implement this recursive function to computenumbers in the Fibonacci sequence:

public static long F(int n){

if (n == 0) return 0;if (n == 1) return 1;return F(n-l) + F(n-2);

}

2.3 Recursion

However, this program is spectacularly inefficient! Novice programmers often refuse to believe this fact, and run code like this expecting that the computer is certainly fast enough to crank out an answer. Go ahead; see if your computer is fastenough to use this program to compute P50. To seewhyit is futile to do so, consider what the function does to compute jF(8) = 21.It first computes F(7) = 13and F(6) = 8.To computeF(7), it recursively computes F(6) = 8 again and F(5)= 5. Things rapidly get worse because both times itcomputes F(6), it ignores the fact that it alreadycomputed F(5), and so forth. In fact, you can proveby induction that the number of timesthis programcomputes F(l) when computing F(n) is preciselyFn (see Exercise 2.3.12). The mistake of recomputa-tion is compounded exponentially. As an example,to compute F(200), the number of times this method needsto compute F(l) is F200 > 1043! No imaginable computer will ever be able to do this manycalculations. Beware ofprograms that might requireexponential time. Many calculations that arise andfind natural expression as recursive programs fallinto this category. Do not fall into the trap of implementing and trying to run them.

The following is one caveat: a systematic technique known as memoization allows us to avoid thispitfallwhilestill takingadvantage of the compactrecursive description of a computation. In memoization, we maintain an array that keeps track of thevalueswe have computed so that wecan return thosevalues and make recursivecallsonly for new values.This technique is a form of dynamicprogramming, awell-studiedtechnique for organizingcomputationsthat you will learn if you take courses in algorithmsor operations research.

F(7)F(6)

F(5)F(4)

F(3)F(2)

F(l)return

F(0)return

return 1

F(l)return 1

return 2

F(2)

F(l)return 1

F(0)return 0

return 1

return 3

F(3)F(2)

F(l)return 1

F(0)return 0

return 1

F(l)return 1

return 2

return 5

F(4)F(3)

F(2)

275

Wrong way to compute Fibonacci numbers


Perspective Programmers who do not use recursion are missing two opportunities. First recursion leads to compact solutions to complex problems. Second,recursive solutions embody an argument that the program operates as anticipated.In the early days of computing, the overhead associated with recursive programswas prohibitive in some systems, and many people avoided recursion. In modernsystems likeJava, recursion is often the method of choice.

If you are intrigued bythe mystery of how the Java system managesto implement the illusion of independentlyoperating copiesof the same piece of code,beassured that we will consider this issue in Chapter 4. Youmay be surprised at thesimplicityof the solution. It is so easyto implement that programmers were usingrecursion well before the advent of high-level programming languages like Java.Indeed, you might be surprised to learn that you could write programs equivalentto the ones considered in this chapter with just the basic loops, conditionals, andarrays programming model discussedin Chapter 1.

Recursion has reinforced for us the idea of proving that a program operatesas intended. The natural connection between recursion and mathematical induc

tion is essential. For everydayprogramming, our interest in correctness is to savetime and energytracking down bugs. In modern applications,security and privacyconcerns make correctness an essential part of programming. If the programmercannot be convinced that an application works as intended, how can a user whowants to keep personal data private and secure be so convinced?

Recursive functions truly illustrate the power of a carefully articulated abstraction. While the concept of a function having the ability to call itself seemsabsurd to many people at first, the many examples that we have considered arecertainly evidence that mastering recursion is essential to understanding and exploiting computation and in understanding the role of computational models instudying natural phenomena.

Recursion is the last piecein a programming model that served to build muchof the computational infrastructure that was developed as computers emerged totake a central role in dailylife in the latter part of the 20th century. Programs builtfrom libraries of functions consisting of statements that operate on primitive typesof data, conditionals, loops, and function calls (including recursive ones) can solveimportant applications of all sorts. In the next section, we emphasize this pointand review these concepts in the context of a large application. In Chapter 3 andin Chapter 4, we will examine extensions to these basic ideas that embrace a moreexpansive style of programming that now dominates the computing landscape.

2.3 Recursion

Q. Are there situations when iteration is the only option available to address aproblem?

A. No,anyloop can be replaced bya recursive function, though the recursive version might require excessive memory.

Q. Are there situations when recursion is the only option available to address aproblem?

A. No, anyrecursive function canbe replaced byan iterative counterpart. In Section 4.3, we will see howcompilers produce code for function calls by usinga datastructure called a stack.

Q. Which should I prefer,recursion or iteration?

A. Whichever leads to the simpler, more easily understood, or more efficientcode.

Q. I get the concern about excessive space and excessive recomputation in recursivecode. Anything else to be concerned about?

A. Be extremely wary of creating arrays in recursive code. The amount of spaceused can pile up very quickly, as can the amount of time required for memorymanagement.

277


2.3.1 What happens if you call facto ri al () with a negativevalue of n? With alarge value, say, 35?

2.3.2 Write a recursive function that computes the value of In (N\)

2.3.3 Givethe sequence of integers printed by a call to ex233(6) :

public static void ex233(int n){

if (n <= 0) return;StdOut.println(n);ex233(n-2);ex233(n-3);StdOut.println(n);

}

2.3.4 Give the value of ex2 34(6):

public static String ex234(int n){

if (n <= 0) return "";return ex234(n-3) + n + ex234(n-2) + n;

}

2.3.5 Criticize the followingrecursivefunction:

public static String ex235(int n){

String s = ex235(n-3) + n + ex235(n-2) + n;if (n <= 0) return "";return s;

}

Answer: The base case will never be reached. A call to ex235 (3) will result in callstoex235(0),ex235(-3),ex235(-6),andsoforthuntilaStackOverflowError.

2.3.6 Given four positive integers a, b, c, and d, explain what value is computedbygcd(gcd(a, b), gcd(c, d)).

2.3 Recursion

2.3.7 Explainin terms of integersand divisors the effect of the following Euclidlike function.

public static boolean gcdlike(int p, int q){

if (q == 0) return (p == 1);return gcdlikeCq, p % q);

}

2.3.8 Consider the following recursive function.

public static int mystery(int a, int b){

if (b == 0) return 0;if (b % 2 == 0) return mystery(a+a, b/2);return mystery(a+a, b/2) + a;

}

What are the values of mystery(2, 25) and mystery(3, 11)? Given positiveintegers a and b, describe what value mystery (a, b) computes. Answer the samequestion, but replace + with *.

2.3.9 Write a recursive program Rul er to plot the subdivisions of a ruler usingStdDraw as in Program 1.2.1.

2.3.10 Solve the following recurrence relations, all with T(l) = 1.Assume N is apower of two.

• T(N) = T(N/2) + 1.• T(N) = 2T(N/2) + 1.•T(N) = 2T(N/2)+iV.• T(N) = 4T(JV/2) + 3.

2.3.11 Prove by induction that the minimum possible number of moves neededto solve the towers of Hanoi satisfies the same recurrence as the number of moves

used by our recursive solution.

2.3.12 Proveby induction that the recursive program givenin the text makes exactly Fn recursive calls to F(l) when computing F(n).

279


2.3.13 Prove that the second argument to gcd() decreases by at least a factor oftwo for every second recursive call, and then prove that gcd(p, q) uses at mostlog2 AT recursive calls whereN is the largerof p and q.

2.3.14 Modify Htree (Program 2.3.4) to animate the drawing of the H-tree.

20% 40% 60% 80% 100%

Next, rearrange the order of the recursive calls (and the base case),view the resulting animation, and explain each outcome.

2.3 Recursion

^BliiiiliiiEfcra^i

2.3.15 Binary representation. Write a program that takes a positive integer N (indecimal) from the command line and prints out its binary representation. Recall, inProgram 1.3.7,that we used the method of subtracting out powersof 2. Instead, usethe following simpler method: repeatedly divide 2 into N and read the remaindersbackwards. First, write a while loop to carry out this computation and print thebits in the wrong order. Then, use recursion to print the bits in the correct order.

2.3.16 A4 paper. The width-to-height ratio of paper in the ISO format is thesquare root of 2 to 1.Format AO has an area of 1square meter.Format Al isAO cutwith a verticalline into two equal halves, A2isAl cut with a horizontal line into intwo halves, and so on. Write a programthat takes a command-line integer n anduses StdDraw to showhow to cut a sheetof AO paper into 2n pieces.

2.3.17 Permutations. Write a program Permutati ons that takesa command-lineargumentnand prints out alln! permutationsof the nlettersstartingat a (assumethat n isno greater than 26). Apermutation of nelements isoneof the n! possibleorderings of the elements. As an example, when n= 3youshould getthe followingoutput. Do not worry about the order in whichyou enumerate them.

bca cba cab acb bac abc

2.3.18 Permutations of size k. Modify Permutations so that it takes two command-lineargumentsnand k, and prints out allP(n,k) = n\ I(n~k)\ permutationsthat contain exactly kof the nelements. Below is the desired output when k= 2 andn = 4.Youneed not print them out in any particular order.

ab ac ad ba be bd ca cb cd da db dc

2.3.19 Combinations. Write a program Combi nati ons that takes one command-line argument n and prints out all 2" combinations of any size. A combination isa subsetof the n elements, independent of order. As an example, when n = 3 youshould get the following output.

a ab abc ac b be c

Note that your program needs to print the empty string (subset of size0).

281


2.3.20 Combinations of size k. Modify Combinations so that it takes two command-line arguments n and fc, and prints out all C(n, k) = n\ I (k$n—k)$ combinations of size k.For example, when n = 5 and k = 3, you should get the followingoutput:

abc abd abe acd ace ade bed bee bde cde

2.3.21 Hamming distance. The Hamming distance between two bit strings oflength n is equal to the number of bits in which the two strings differ. Write aprogram that readsin an integer k and a bit string s from the command line,andprints out allbit stringsthat have Hammingdistance at most kfrom s. Forexampleif k is 2 and s is 0000, then your program should print

0011 0101 0110 1001 1010 1100

Hint: Choose k of the n bits in s to flip.

2.3.22 Recursive squares. Writea program to produce eachof the following recursive patterns. The ratio of the sizes of the squares is 2.2:1. To drawa shadedsquare,draw a filled graysquare,then an unfilled blacksquare.

2.3.23 Pancake flipping. You have a stack of n pancakes of varying sizes on agriddle. Your goal is to rearrange the stackin descending order so that the largestpancake is on the bottom and the smallest one is on top.You are onlypermitted toflip the top kpancakes,thereby reversing their order. Devisea recursive scheme toarrange the pancakesin the proper order that usesat most In —3 flips.

2.3.24 Gray code. Modify Beckett (Program 2.3.3) to print out the Gray code(not just the sequence of bit positions that change).

2.3 Recursion

2.3.25 Towers of Hanoi variant. Consider the following variant of the towers ofHanoi problem. There are 2n discs of increasing sizestored on three poles. Initiallyall of the discs with odd size (1, 3,..., 2n-l) are piled on the left pole from top tobottom in increasing order of size; all of the discs with even size (2, 4,..., 2n) arepiled on the right pole.Write a program to provide instructions for moving the order iodd discsto the right pole and the evendiscs to the left pole,obeyingthe samerules as for towers of Hanoi.

2.3.26 Animated towers of Hanoi. Use StdDraw to animate a solution to thetowers of Hanoi problem, moving the discs at a rate of approximately 1 persecond.

2.3.27 Sierpinski triangles. Write a recursive program to draw Sierpinskitriangles (see Program 2.2.3). Aswith Htree, use a command-line argument tocontrol the depth of the recursion.

2.3.28 Binomial distribution. Estimate the number of recursive calls that

would be used by the code

public static double binomial(int N, int k){

if ((N == 0) [I (k < 0)) return 1.0;return (binomial(N-l, k) + binomial(N-l, k-l))/2.0;

}

Sierpinskitriangles

to compute bi nomi al (100, 50). Develop a better implementation that is basedon memoization. Hint: See Exercise 1.4.37.

2.3.29 Collatzfunction. Consider the following recursive function, which is related to a famous unsolvedproblem in number theory,known as the Collatzproblem^or the 3n+l problem:


public static void collatz(int n){

StdOut.print(n + " ");if (n == 1) return;if (n % 2 == 0) collatz(n / 2);else collatz(3*n + 1);

}

For example, a call to col 1atz (7) prints the sequence

7 22 11 34 17 52 26 13 40 20 10 5 16 8 4 2 1

as a consequence of 17recursive calls. Write a program that takes a command-lineargument Nand returns the value of n < Nfor whichthe number of recursive callsfor col 1atz (n) is maximized.The unsolvedproblem is that no one knows whetherthe function terminates for all positivevalues of n (mathematical induction is nohelp,because one of the recursive calls is for a largervalueof the argument).

2.3.30 Brownian island. B. Mandelbrot asked the famous question How long isthe coast ofBritain? ModifyBrowni an to geta program Browni anlsl and that plotsBrownian islands, whose coastlines resemble that of Great Britain. The modifications are simple: first,changecurve () to add a Gaussianto the x-coordinate aswellas to the/-coordinate; second, change mai n() to drawa curvefrom the point at thecenter of the canvasback to itself. Experimentwith various valuesof the parametersto getyour program to produce islands with a realistic look.

Brownian islands withHurstexponentof .76

2.3.31 Plasmaclouds. Write a recursive program to draw plasma clouds, using themethod suggested in the text.

2.3 Recursion

2.3.32 A strangefunction. Consider McCarthy's 91 function:

public static int mcCarthy(int n){

if (n > 100) return n - 10;return mcCarthy(mcCarthy(n+ll));

}

Determine the value of mcCarthy(50) without using a computer. Givethe numberof recursive calls used by mcCarthy() to compute this result. Prove that the basecase is reached for all positive integers n or givea value of n for which this functiongoes into a recursive loop.

2.3.30 Recursive tree. Write a program Tree that takesa command-line argumentNand produces the following recursivepatterns for Nequal to 1,2,3,4, and 8.

1 T

285


2.4 Case Study; Percolation

The programmingtools that we have considered to this point allow us to attack allmanner of important problems.Weconcludeour study of functions and modulesby consideringa casestudy of developing a program to solve an interestingscientific problem. Our purpose in doing so isto review the basic elements that we have

covered, in the context of the various 2.4.1 Percolation scaffolding ...... .290challenges that you might face in solv- 2-4-2 Vertical percolation detection 292ing a specific problem, and to illustrate ^.4.3 VisualizationcUent ..... .295

° . , , , 2.4.4 Percolation probabilityestimate . .297a programming style that you can apply 245 PerColationdetection 299broadly. 2.4.6 Adaptive plot client 302

Our example applies a computing Progmms fa m$sectiontechnique to a simple model that has beenextremely useful in helping scientists andengineers in numerous contexts.Weconsider a widely applicable technique knownas Monte Carlo simulation to study a natural model known as percolation. This isnot just of direct importance in materials science and geology, but also explainsmany other natural phenomena.

The term "Monte Carlo simulation" is broadly used to encompass any technique that employs randomness to generate approximate solutions to quantitativeproblems. We have used it in several other contexts already—for example, in thegambler's ruin and coupon collector problems. Rather than develop a completemathematical model or measure all possible outcomes of an experiment, we relyon the lawsof probability.

Wewill learn quite a bit about percolation in this case study,but our focus ison the process of developing modular programs to address computational tasks.We identify subtasks that can be independently addressed, striving to identify thekey underlying abstractions and asking ourselvesquestions such as the following:Is there some specific subtask that would help solve this problem? What are the essential characteristics of this specificsubtask? Might a solution that addresses theseessential characteristics be useful in solving other problems? Asking such questionspays significant dividend, because they lead us to develop software that is easier tocreate, debug, and reuse, so that we can more quickly address the main problem ofinterest.

2.4 Case Study: Percolation

Percolation It is not unusual for localinteractions in a system to imply globalproperties. For example, an electrical engineer might be interested in compositesystemscomprised of randomly distributed insulating and metallic materials: whatfraction of the materials need to be metallic so that the composite system is anelectrical conductor? As another example, a geologist might be interested in a porous landscape with water on the surface (or oil below). Under what conditions willthe water be able to drain through to the bottom (or the oil to gush through to thesurface)? Scientistshave defined an abstract processknown aspercolation to modelsuch situations. It has been studied widely, and shown to bean accurate model in a dizzying variety of applications, beyond insulating materials and porous substances to thespread of forest fires and disease epidemics to evolution tothe study of the internet.

For simplicity,we begin by working in two dimensionsand model the system as an N-by-iV grid of sites. Each siteis either blocked or open; open sitesare initiallyempty. Afullsite is an open site that can be connected to an open site inthe top row via a chain of neighboring (left,right, up, down)open sites. If there is a full site in the bottom row, then wesay that the systempercolates. In other words, a systempercolates if we fill all open sites connected to the top row andthat process fills some open site on the bottom row. For theinsulating/metallic materials example, the open sites correspond to metallic materials, so that a system that percolateshas a metallic path from top to bottom, with full sites conducting. For the porous substance example, the open sitescorrespond to empty space through which water mightflow, so that a system that percolates lets water fillopen sites,flowing from top to bottom.

In a famous scientific problem that has been heavilystudied for decades, researchers are interested in the following question: if sites are independently set tobe open with vacancy probability p (and therefore blocked with probability 1—p)ywhat is the probability that the system percolates? No mathematical solution tothis problem has yet been derived. Our task is to write computer programs to helpstudy the problem.

percolates

emptyopen —*-|site

287

blockedsite

full-open

site

opensiteconnected to top

doesnotpercolate

no opensite connected to top

Percolation examples


Basic scaffolding To address percolation with a Java program, weface numerous decisions and challenges, and we certainly will end up with much more codethan in the short programs that we have considered so far in this book. Our goal isto illustrate an incremental styleof programming where we independently develop

modules that address parts of the problem, building confidencewith a small computational infrastructure of our own design andconstruction as we proceed.

The first step is to pick a representation of the data. This decision can have substantial impact on the kind of code that we writelater, so it is not to be taken lightly. Indeed, it is often the case thatwe learn something while working with a chosen representationthat causesus to scrap it and start all over using a new one.

For percolation, the path to an effective representation isclear: use two-dimensionalarrays.What type of data should we usefor each entry? One possibility is to use integers, with a code suchas 0 to indicate an empty site, 1 to indicate a blocked site, and 2 toindicate a fullsite.Alternatively, note that we typicallydescribesitesin terms of questions: Is the site open or blocked? Is the site full orempty? This characteristic of the entries suggests that we might useboolean matrices, where all entries are true or fal se.

Boolean matrices are fundamental mathematical objectswith manyapplications. Java itselfdoes not provide direct supportfor operations on boolean matrices, but we can use the methodsin StdArraylO (see Program 2.2.2) to read and write them. Thischoiceillustrates a basicprinciple that often comes up in programming: the effort required to build a more general tool usually paysdividends. Using a natural abstraction such as boolean matrices ispreferable to usinga specialized representation.In the present context, it turns out that using boo! ean instead of i nt matrices alsoleads to code that is easier to understand. Eventually, we will wantto work with random data, but we also want to be able to read and

write to files because debugging programs with random inputs canbe counterproductive. With random data, you get different input

each time that you run the program;after fixing a bug, what you want to see is thesame input that you just used, to checkthat the fix was effective. Accordingly, it isbest to start with some specific cases that we understand, kept in files formatted to

percolation system

blocked sites

open sites0 0 11

0

1

0

1

1

0

1

full sites0 0 1

Percolation representations


be read by StdAr raylO. readBool ean2D() (dimensions followed by 0 and 1 valuesin row-major order).

When you start working on a new problem that involves several files, it is usuallyworthwhile to create a new folder (directory) to isolate those files from othersthat you may be working on. For example, we might start with stdl i b. jar in afolder named percol ati on, so that we have access to the methods in our librariesStdArraylO.Java, Stdln.Java,StdOut.Java, StdDraw.Java, StdRandom.Java,

and StdStats. j ava. We can then implement and debug the basic code for readingand writing percolation systems, create test files, check that the files are compatible with the code, and so forth, before really worrying about percolation at all.This type of code, sometimes called scaffolding, is straightforward to implement,but making sure that it is solid at the outset willsave us from distraction when approaching the main problem.

Now we can turn to the code for testing whether a boolean matrix representsa system that percolates. Referring to the helpful interpretation in which we canthink of the task assimulatingwhatwouldhappen if the top werefloodedwith water (does it flowto the bottom or not?), our firstdesigndecisionis that we willwantto have a flow() method that takes as an argument a two-dimensional booleanarrayopen[] [] that specifies whichsites areopen and returns another two-dimensionalboolean array f ul 1[] [] that specifies whichsites are full. For the moment,wewillnot worry at all about howto implementthis method;we are just decidinghow to organize the computation. It is also clear that we willwant client code tobe able to use a percolatesO method that checks whether the array returned byf 1ow() has any full sites on the bottom.

Percolation (Program 2.4.1) summarizes these decisions. It does not perform any interesting computation, but, after running and debuggingthis code wecan start thinking about actuallysolving the problem.A method that performs nocomputation,such as f1ow(), issometimes called a stub. Having this stub allows usto test and debug percol ates () and mai n() in the context in which wewillneedthem. We refer to code like Program 2.4.1 as scaffolding. As with scaffolding thatconstruction workers use when erectinga building, this kind of code provides thesupport that we need to develop a program. Byfully implementingand debuggingthis code (much, if not all, of which we need, anyway) at the outset, we provide asound basis for building code to solve the problem at hand. Often, we carry theanalogy one stepfurther and remove the scaffolding (or replace it with somethingbetter) after the implementation is complete.


%k?i

§£4

•••'.:•*'

1

m

:r0^ri^pM^^ii^^^^^^

Program 2A.1 Percolation scaffolding

public class Percolation{

public static boolean[][] flow(boolean[] [] open){

int N = open.length;boolean[][] full = new boolean[N][N];// Percolation flow computation goes here,return full;

}

public static boolean percolates(boolean[][] open){

boolean[][] full = flow(open);int N = full.length;for (int j = 0; j < N; j++)

if (full[N-l][j]) return true;return false;

}

N

full[][]

open[][]


boolean[][] open = StdArraylO.readBoolean2D();StdArrayIO.print(flow(open));StdOut.pri ntln(percolates(open));

}

systemsize (N-by-N)

full sitesopen sites

To get started with percolation, we implement and debug this code, which handles all thestraightforward tasks surrounding the computation. The primaryfunction flow() returns anarray giving the full sites (none, in the placeholder code here). The helper function perco-1ates() checks the bottom row of the returned array to decide whether the system percolates.The test client mai n() reads a boolean matrix from standard input andthen prints the resultofcalling f 1ow() and percol ates () for thatmatrix.


Vertical percolation Given a boolean matrix that represents the open sites,how do we figure out whether it representsa systemthat percolates? Aswe will seeat the end of this section, this computation turns out to be directly related to afundamental question in computer science. For the moment, we will consider a

much simpler version of the problem that we call vertical percolation.

The simplification is to restrict attention to vertical connection paths. If such a path connects top to bottom in a system, we saythat the system vertically percolates along the path(and that the system itself vertically percolates). This restriction is perhaps intuitive if we are talking about sand travelingthrough cement,but not if weare talkingabout water travelingthrough cementor about electrical conductivity. Simpleas it is,vertical percolation is a problem that is interesting in its ownright becauseit suggests variousmathematicalquestions. Doesthe restriction make a significant difference? How many vertical percolation paths do we expect?

Determining the sites that are filled by some path thatis connected vertically to the top is a simple calculation. Weinitialize the top row of our result array from the top row ofthe percolation system, with full sites corresponding to openones.Then, movingfrom top to bottom, we fill in each row ofthe arraybychecking the corresponding rowof the percolation

system. Proceeding from top to bottom, we fill in the rows of f ul1[] [] to markas true all entries that correspond to sites in open[] [] that are vertically connected to a full site on the previous row.Program 2.4.2 is animplementation of f 1ow() for Percol ation that returns aboolean array of full sites (t rue if connectedto the top viaa vertical path, f al se otherwise).

vertically percolates

site connected to topwith a vertical path

doesnot vertically percolate

no open site connected totopwitha vertical path

Vertical percolation

291

connectedto top via avertical path offilled sites

Testing Afterwe become convincedthat our code is behaving asplanned,wewant to run it on a broadervariety oftest cases and address some of our scientific questions. Atthis point, our initial scaffolding becomes less useful, asrepresenting largebooleanmatrices with Os and Is on standardinput and standard output and maintaining largenumbers

H^-X!notconnected to top \|

via such apath connected to topvia sucha path

Vertical percolation calculation


mi

m

public static boolean[][] flow(boolean[] [] open){ // Compute full sites for vertical percolation

int N = open.length;boolean[][] full = new boolean[N][N];for (int j = 0; j < N; j++)

full[0][j] = open[0][j];

N

full[][]

open[][]

system size (N-by-N)

full sitesopensites

for (int i = 1; i < N; i++)for (int j = 0; j < N; j++)

full[i][j] = open[i][j] && full [i-1] [j];return full;

•^^^^^^^^^^^^p^^

Substituting this methodforthe stub inProgram 2.4.2 gives a solution to the vertical-only percolation problem that solves our test case asexpected (see text).

'^^^^S^^^^^^^^^^^^^^^^^'

^^^P^S^^^^5^^^^^^^^/^^^ ^WS^P^P

of test cases quickly becomes uninformative and unwieldy. Instead, wewant to automatically generate test cases and observe the operation of our code on them, tobe surethat it isoperating asweexpect. Specifically, to gainconfidence in our codeand to develop a betterunderstanding of percolation, our nextgoals are to:

• Test our code for large random inputs.• Estimate the probabilitythat a system percolates for a given p.

To accomplish these goals, we neednewclients that areslightly moresophisticatedthanthescaffolding we used toget theprogram up andrunning. Ourmodular programming style is to develop suchclients in independent classes without modifyingourpercolation codeat all.


Data visualization. We can work with much bigger problem instances if we useStdDraw for output. The following static method for Percolation allows us tovisualize the contents of boolean matrices as a subdivision of the StdDraw canvas

into squares, one for each site.

public static void show(boolean[][] a, boolean which){

int N = a.length;StdDraw.setXscale(-l, N);StdDraw.setYscale(-l, N);for (int i = 0; i < N; i++)

for (int j = 0; j < N; j++)if (a[i][j] == which)

StdDraw.fi11edSquare(j, N-i-1, .5);}

The second argument which specifieswhether we want to display the entries corresponding to true or to f al se. This method is a bit of a diversion from the calculation, but pays dividends in its ability to help us visualize large problem instances.Using show() to draw our arrays representing blocked and full sites in differentcolors gives a compelling visual representation of percolation.

Monte Carlo simulation. We want our code to work properly for any booleanmatrix. Moreover, the scientific question of interest involves random matrices. Tothis end, we add another static method to Percol ati on:

public static boolean[][] random(int N, double p){

boolean[][] a = new boolean[N] [N];for (int i =0; i < N; i++)

for (int j = 0; j < N; j++)a[i][j] = StdRandom.bernoulli(p);

return a;

}

This method generates a random N-by-N matrix of any givensize,each entry truewith probability p. Having debugged our code on a few specific test cases, we areready to test it on random systems. It is possible that such cases may uncover a fewmore bugs, so some care is in order to checkresults.However, having debugged ourcode for a small system, we can proceed with some confidence. It is easier to focuson new bugs after eliminating the obvious bugs.


With these tools, a client for testing our percolation code on a much larger setof trials is straightforward. Visualize (Program 2.4.3) consists of just a main()method that takes N and p from the commandline, generates T trials (takingthisnumber from the command line), and displays the result of the percolation flowcalculation for each case,pausing for a brief time between cases.

This kind of client is typical. Our eventual goal is to compute an accurateestimate of percolation probabilities, perhaps by running a large number of trials,but this simple tool gives us the opportunity to gain more familiarity with theproblem by studying some large cases (while at the same time gaining confidencethat our code is working properly). Before reading further, you are encouraged todownload and run this code from the booksite to study the percolation process.When you run Visual i ze for moderate sizeN (50 to 100,say) and various p, youwill immediately be drawn into using this program to try to answer some questionsabout percolation. Clearly, the system never percolates when p is low and alwayspercolates when p is very high. How does it behave for intermediate values of p?How does the behavior change as N increases?

Estimating probabilities Thenextstep in our programdevelopment processis to write code to estimate the probability that a random system (of size N withsite vacancy probability p) percolates. We refer to this quantity as the percolationprobability. To estimate its value, we simply run a number of experiments. Thesituation is no different than our study of coin flipping (see Program 2.2.6), butinstead of flipping a coin, we generate a random system and check whether or notit percolates.

Esti mate (Program 2.4.4) encapsulates this computation in a method eval ()that returns an estimate of the probability that an N-by-N system with site vacancyprobability p percolates, obtained by generating T random systems and calculatingthe fraction of them that percolate. The method takes three arguments: N, p, andT.

How many trials do we need to obtain an accurate estimate? This questionis addressed by basic methods in probability and statistics, which are beyond thescope of this book, but we can get a feeling for the problem with computationalexperience. With just a few runs of Estimate, you can learn that the site vacancyprobability is close to 0 or very close to 1, then we do not need many trials, butthat there are values for which we need as many as 10,000 trials to be able to estimate it within two decimal places. To study the situation in more detail, we might


Program 2.4.3 Visualization client

public class Visualize{


int N = Integer.parselnt(args[0]);double p = Double.parseDouble(args[l]);int T = Integer.parselnt(args[2]);for (int t = 0; t < T; t++)

{boolean[][] open = Percolation.random(N, p);StdDraw.clear();StdDraw.setPenColor(StdDraw.BLACK);Percolation.show(open, false);StdDraw.setPenColor(StdDraw.BLUE);boolean[][] full = Percolation.flow(open);Percolation.show(full, true);StdDraw.show(lOOO);

>>

N

P

T

open[][]

full[][]

295

system size (N-by-N)site vacancy probability

numberof trials

opensites

full sites-mmmmmmMMm

This client generates N-by-N random instances with site vacancy probability p, computes thedirected percolation flow, anddraws the result on StdDraw. Such drawings increase confidencethat our code is operating properly and help develop an intuitive understanding of percolation.


modify Estimate to produce output like Bernoulli (Program 2.2.6), plotting ahistogram of the data points so that we can see the distribution of values (see Exercise 2.4.10).

Using Estimate. eval () represents a giant leap in the amount of computation that we are doing. All of a sudden, it makes sense to run thousands of trials.It would be unwise to try to do so without first having thoroughly debugged ourpercolation methods. Also, we need to begin to take the time required to completethe computation into account. The basic methodology for doing so is the topic ofSection 4.1, but the structure of these programs is sufficientlysimple that we cando a quick calculation, which we can verifyby running the program. We are doingT trials, each of which involve N2 sites, so the total running time of Estimate,eval () is proportional to N2T. If we increase T by a factor of 10 (to gain moreprecision), the running time increasesby about a factor of 10. If we increase JV bya factor of 10 (to study percolation for larger systems), the running time increasesby about a factor of 100.

Can we run this program to determine percolation probabilities for a systemwith billions of sites with several digits of precision? No computer is fast enoughto use Esti mate. eval () for this purpose. Moreover, in a scientific experiment onpercolation, the value of N is likelyto be much higher.We can hope to formulate ahypothesisfrom our simulation that can be testedexperimentallyon a much largersystem,but not to preciselysimulatea systemthat corresponds atom-for-atom withthe real world. Simplification of this sort is essential in science.

You are encouraged to download Esti mate from the booksite to get a feelforboth the percolation probabilities and the amount of time required to computethem. When you do so, you are not just learning more about percolation, but alsoyou are testing the hypothesis that the models we have just described apply to therunning times of our simulations of the percolation process.

What is the probabilitythat a system with sitevacancyprobabilityp verticallypercolates? Vertical percolation is sufficiently simple that elementary probabilisticmodels can yield an exact formula for this quantity, which we can validate experimentally with Estimate. Since our only reason for studying vertical percolationwas an easystarting point around which we could develop supporting software forstudying percolation methods, weleave further study of vertical percolation for anexercise (see Exercise 2.4.11) and turn to the main problem.


$0<

m

||

^MSMM£^^

Program 2.4.4 Percolation probability estimate

public class Estimate{

public static double eval(int N, double p, int T){ // Generate T random networks, return empirical

// percolation probability estimate.int cnt = 0;for (int t = 0; t < T; t++){ // Generate one random network.

boolean[][] open = Percolation.random(N, p);if (Percolation.percolates(open)) cnt++;

}return (double) cnt / T;

}public static void main(String[] args){

int N = Integer.parselnt(args[0]);double p = Double.parseDouble(args[l]);int T = Integer.parselnt(args[2]);double q = eval(N, p, T);StdOut.println(q);

N

P

T

open[][]

q

system size (N-by-N)

site vacancy probability

number of trials

open sites

percolation probability

}•^^^^^m^^m^^mmmm^

}

To estimate theprobability thata network percolates, wegenerate random networks andcomputethefraction of them that percolate. This isa Bernoulli process, nodifferent than coin flipping (see Program 2.2.6). Increasing the number oftrials increases the accuracy of the estimate.If thesitevacancy probability is close to0 or to 1, notmany trials areneeded.

% Java Estimate 20 .5 100.0




% Java Estimate 20 .85 10000.564

% Java Estimate 20 .85 10000.561


^^^^•^^•^^S^^^^^^^'^P^W-


Recursive solution for percolation Howdo wetestwhethera system percolatesin the generalcasewhen any path starting at the top and ending at the bottom(not just a vertical one) will do the job?

Remarkably, we can solvethis problem witha compact program, based on a classic recursivescheme known as depth-firstsearch. Program 2.4.5is an implementation of flow() that computesthe flowarray,based on a recursivefour-argumentversion of f 1ow() that takes as arguments the sitevacancy array open[] [], the flow array full [][], and a site position specified by a row index iand a column index j. The base case is a recursivecall that just returns (we refer to such a call as anullcall),for one of the following reasons:

• Either i or j are outside the array bounds.• The site is blocked (open [i ] [j] is f al se).• Wehave already marked the site as full(full[i][j] is true).

The reduction case is to mark the site as filled and

issue recursive calls for the site's four neighbors:open[i+l][j], open[i][j+l], open[i] [j-1],and open[i-l] [j]. To implement flow(), wecall the recursive method for every site on thetop row.The recursion always terminates becauseeach recursive call either is null or marks a new

site as full. We can show by an induction-basedargument (as usual for recursive programs) that asite is marked as full if and only if it is connectedto one of the sites on the top row.

Tracing the operation of flow() on a tinytest case is an instructive exercise in examiningthe dynamics of the process. The function callsitself for every site that can be reached via a path of open sites from the top. Thisexample illustrates that simple recursive programs can mask computations thatotherwise are quite sophisticated. This method is a specialcaseof the classicdepth-first search algorithm, which has many important applications.

flow(...,0,0)

flow(.

flow(...,l,4)

,2,4)

.,3,4)

flow(...,3,3)

flow(...,4,3)

flow(...,3,2)

1 flow(...,2,2)

Recursive percolation (null calls omitted)


Program2.4.5 Percolation detection

public static boolean[][] flow(boolean[] [] open){ // Fill every site reachable from the top row.

int N a open.length;boolean[][] full = new boolean[N][N];for (int j = 0; j < N; j++)

flow(open, full, 0, j);return full;

}public static void flow(boolean[] [] open,

boolean[][] full,{ // Fill every site reachable from (i,

int N = full.length;if (i < 0 || i >= N) return;if (j < 0 j j j >= N) return;if (!open[ij [j]) return;if (full[i][j]) return;full[i][j]flow(open,flow(open,flow(open,flow(open,

= true;

full, i+1, j);full, i, j+1);full, i, j-1);full, i-1, j);

// Down.// Right.// Left.// Up.

299

Substituting these methods for the stub inProgram 2.4.1 gives a depth-first-search-based solution to the percolation problem. The recursive f1ow()fills sites by setting to true the entry inf ul1[] [] corresponding to anysitethat can bereached from open[i ] [j] via a path of opensites. The one-argument f1ow() calls the recursive methodforevery siteon the top row.

% more test8.txt

8 8

I

wmmmmmmmmmm*

% Java Percolation < test8.txt8 8

true

wmmmmmmmmmmmmmwm:

*


To avoid conflict with our solution for vertical percolation (Program 2.4.2),we might rename that class Percol ati onEZ, making another copy of Percolation (Program 2.4.1) and substituting the two flow() methods in Program 2.4.5for the placeholder f low(). Then, we can visualize and perform experiments withthis algorithm with the Visual i ze and Experi ment tools that we have developed.If you do so,and try various valuesfor N and p, you will quicklyget a feelingfor thesituation: the systemsalways percolatewhenp is high and never percolate whenp islow, and (particularly as N increases) there is a value of p above which the systems(almost) always percolate and belowwhich they (almost) never percolate.

% java Visualize 20 .65 1 % Java Visualize 20 .60 1 % Java Visualize 20 .55 1

Percolation is less probable as thesitevacancy probability decreases

Having debuggedVisualize and Experiment on the simple vertical percolationprocess, we can use them with more confidence to study percolation, and turnquickly to study the scientific problem of interest.Note that if we want to experiment with vertical percolation again, we would need to edit Visualize and Experiment to refer to Percol ati onEZ instead of Percolation, or write other clients ofboth Pe r col ati onEZ and Pe r col ati on that run methods in both classes to

compare them.

Adaptive plot Togain more insight into percolation,the next step in programdevelopment is to write a program that plots the percolation probability as a function of the site vacancyprobabilityp for a given value of N. Perhaps the best wayto produce such a plot is to first derivea mathematical equation for the function,and then use that equation to make the plot. For percolation, however, no one hasbeen able to derive such an equation, so the next option is to use the Monte Carlomethod: run simulations and plot the results.


Immediately, we are faced with numerous decisions. For how many valuesofp should we compute an estimateof the percolationprobability? Which valuesofpshould we choose? How much precision should we aim for in these calculations?Thesedecisions constitute an experimental design problem.Much aswemight liketo instantlyproduce an accuraterendition of the curvefor anygivenJV, the computation cost can be prohibitive. For example,the first thing that comes to mind is toplot, say, 100to 1,000 equallyspacedpoints, using StdStats (Program 2.2.5).But,as you learned from using Esti mate, computing a sufficiently precisevalue of thepercolation probability for each point might take several seconds or longer, so thewhole plot might take minutes or hours or evenlonger.Moreover, it is clear that alot of this computation time is completelywasted, becauseweknow that values forsmall p are 0 and values for largep are 1.We might prefer to spend that time onmore precise computations for intermediate p. How should we proceed?

PercPlot (Program 2.4.6) implements a recursiveapproach with the same structure as Brownian (Program2.3.5) that is widelyapplicable to similar problems.The basic idea is simple: we choose the minimum distance that wewant between values of the x-coordinate (which we refer toas the gap tolerance), the minimum known error that wewish to tolerate in the/-coordinate (whichwerefer to as theerror tolerance), and the number of trials Tper point thatwe wish to perform. The recursive method draws the plotwithin a given interval [x0, xj, from (x0, yQ) to (xvyx). Forour problem, the plot is from (0,0) to (1,1). The base case (if the distance betweenx0 and xx is lessthan the gap tolerance, or the distance between the line connectingthe two endpoints and the valueof the function at the midpoint is lessthan the error tolerance) is to simply drawa linefrom (x0,y0) to (xvyl). The reduction step isto (recursively) plot the two halves of the curve, from (x0,y0) to (xm,ym) and from(xm>ym)to{xvyl).

Thecodein Pere PIot isrelatively simple and produces a good-looking curveat relatively lowcost.Wecan use it to studythe shapeof the curvefor various valuesof AT or choose smaller tolerances to be more confident that the curve is close to the

actualvalues. Precise mathematical statementsabout qualityof approximation can,in principle,be derived,but it isperhaps not appropriate to go into too much detailwhile exploring and experimenting,sinceour goal is simply to develop a hypothesis about percolation that can be tested by scientificexperimentation.

error

tolerance

301

(xvy0

Adaptive plot tolerances


^^rv^sz}^

Program 2.4.6 Adaptiveplot client

public class PercPlot{

public static void curve(int N,double xO, double yO,double xl, double yl)

{ // Perform experiments and plot results,double gap = .005;double err = .05;int T = 10000;double xm = (xO + xl)/2;double ym = (y0 + yl)/2;double fxm = Estimate.eval(N, xm, T);if (xl - xO < gap && Math.abs(ym - fxm) < err){

StdDraw.line(xO, yO, xl, yl);return;

}curve(N, xO, yO, xm, fxm);StdDraw.filledCircle(xm, fxm, .005);curve(N, xm, fxm, xl, yl);

}

}

public static void main(String[] args){ // Plot experimental curve for N-by-N percolation system

int N = Integer.parselnt(args[0]);curve(N, 0.0, 0.0, 1.0, 1.0);

}

N

xO, yO

xl, yl

xm, ym

fxm

gap

err

T

system size

leftendpoint

rightendpoint

midpoint

valueat midpoint

gap tolerance

error tolerance

number of trials

This recursive program draws aplotofthe percolation probability (experimental observations)against the sitevacancy probability (control variable).

% Java PercPlot 20

l-

perxolationprobability

0 0.593 1

site vacancy probability p

9^m^^^^^^^^^^^^^^^0^§^]^t^^^^^^^«>^^^^^^^^"

1 i % Java PercPlot 100

; l-

percolationprobability

0 0.593 1

site vacancy probability p

s

4IfWlPro^


Indeed, the curves produced by PercPlot immediately confirm the hypothesis that there is a threshold value (about .593): if p is greater than the threshold,then the system almost certainly percolates; if p is less thanthe threshold, then the system almost certainly does not percolate. As N increases, the curve approaches a step functionthat changes valuefrom 0 to 1at the threshold.Thisphenomenon, known as a phase transition, is found in manyphysicalsystems.

The simple form of the output of Program 2.4.6masksthe huge amount of computation behind it. Forexample, thecurve drawn for JV = 100 has 18 points, each the result of10,000 trials, each trial involving JV2 sites. Generating andtestingeachsite involves a fewlinesof code,so this plot comesat the cost of executing billions of statements. There are twolessons to be learned from this observation: First, we need tohave confidence in any line of code that might be executedbillions of times, so our care in developing and debuggingcode incrementallyis justified. Second, althoughwemight beinterested in systems that are much larger, we need furtherstudy in computer scienceto be to handle larger cases: to develop faster algorithms and a framework for knowing theirperformance characteristics.

With this reuse of all of our software,we can study allsorts of variants on the percolation problem, just by implementing different f 1ow() methods. For example, if you leaveout the last recursive call in the recursive flow() method inProgram 2.4.6, it tests for a type of percolation known as directed percolation, where paths that go up are not considered.This model might be important for a situation like a liquidpercolating through porous rock, where gravitymight play arole,but not for a situation likeelectrical connectivity. If yourun PercPlot for both methods, will you be able to discernthe difference (see Exercise 2.4.5)?

To model physical situations such as water flowingthrough porous substances, we need to use three-dimensional arrays. Is there asimilar threshold in the three-dimensional problem? If so, what is its value? Depth-

PercPlot.curveOEstimate.evalO

Percolation.random()StdRandom.bernoul1i()

• N2 times

StdRandom.bernoulli()return

Percolati on.percolates()flow()return

return

• T times

Percolation. random0StdRandom.bernoul1 iO

• N2 times

StdRandom.bernoul1i()return

Pe rcolati on.percolates()flowOreturn

return

return

. oncefor eachpoint

Estimate.eval()Pe rcolati on.random()

StdRandom.bernoul1i()

• N2 times


Percolation.percolates()flowOreturn

return

• T times

Percolation.randomOStdRandom.bernoul1i()

• M2 times


Percolati on.percolates()flowOreturn

return

return

return

Call tracefor Java PercPlot


first search is effective for studying this question, though the addition of anotherdimension requires that wepayeven more attention to the computational costof

determiningwhethera system percolates (seeExercise 2.4.19). Scientists also study more complex lattice structures that are not well-modeledbymultidimensional arrays—we willseehowto model suchstructures in Section 4.5.

Percolation is interesting to study via in silico experimentationbecause no one has been able to derive the threshold value mathemat

ically for several natural models. The only waythat scientists knowthe valueis by usingsimulations like Percol ati on.A scientistneedsto do experimentsto seewhether the percolation model reflects whatis observed in nature, perhaps through refining the model (for example, using a different lattice structure). Percolation is an exampleof an increasingnumber of problems where computer scienceof thekind describedhere is an essential part of the scientificprocess.

percolates (pathnevergoesup)

doesnotpercolate

Directed percolation LessoBS Wemight have approached the problem of studying percolation by sitting down to design and implement a single program,

which probably would run to hundreds of lines, to produce the kind of plots thatare drawn by Program 2.4.6. In the early days of computing, programmers hadlittle choice but to work with such programs, and would spend enormous amountsof time isolating bugs and correcting design decisions.With modern programmingtools like Java, we can do better, using the incremental modular style of programming presented in this chapter and keeping in mind some of the lessons that wehave learned.

Expect bugs. Every interesting piece of codethat youwrite isgoingto have at leastone or two bugs, if not many more. By running small pieces of code on small testcases that you understand, you can more easily isolate any bugs and then moreeasily fix them when you find them. Once debugged, you can depend on using alibrary as a building block for any client.

Keep modules small. You canfocus attentionon at mosta few dozenlinesof codeat a time, so you may as well break your code into small modules as you write it.Some classesthat contain libraries of related methods may eventually grow to contain hundreds of lines of code; otherwise, we work with small files.


Limit interactions. In a well-designed modular program, most modules shoulddepend on just a few others. In particular, a module that calls a large number ofother modules needs to be divided into smaller pieces. Modules that arecalled byalarge number of other modules (you should have only a few) need special attention, becauseif you do need to makechanges in a module'sAPI,you haveto reflectthose changes in all its clients.

Develop code incrementally. You should run anddebug each small module asyouimplement it. That way, you are neverworkingwith more than a fewdozen lines ofunreliable code at any giventime. If you putall your code in one big module, it is difficult to be confident that anyof it is safefrombugs. Running code earlyalso forces you tothink sooner rather than later about I/O for

mats, the nature of problem instances, andother issues. Experiencegained when thinking about such issues and debuggingrelatedcode makes the code that you develop laterin the process more effective.

Solve an easier problem. Some workingsolution is better than no solution, so it istypical to begin by putting together the simplest code that you can craft that solves agiven problem, as we did with vertical-onlypercolation. This implementation is the firststep in a process of continual refinementsand improvements as we develop a morecomplete understanding of the problembyexamining a broadervariety of testcases and developing support software suchas our Visual i ze and Experi ment classes.

305

Case study dependencies (not including system calls)

Consider a recursive solution. Recursion isanindispensable tool in modern programming that you should learn to trust. If you are not already convinced of thisfact bythe simplicity and elegance of PercPlot and Percolati on,youmightwishto try to develop a nonrecursive program for testingwhether a system percolatesand then reconsider the issue.


Build tools when appropriate. Our visualization method show() and randomboolean matrix generation method random () are certainly useful for many otherapplications, as is the adaptiveplotting method of PercPlot. Incorporating thesemethods into appropriate librarieswouldbe simple.It is no more difficult(indeed,perhapseasier) to implementgeneral-purpose methods likethese than it wouldbeto implement special-purpose methods for percolation.

Reuse software when possible. Our Stdin, StdRandom, and StdDraw libraries allsimplified the process of developing the codein this section, and wewere also immediately able to reuse programs suchas PercPlot, Esti mate, and Vi sual i ze forpercolation afterdeveloping them for vertical percolation. After you have writtena few programs of this kind, youmightfind yourself developing versions of theseprograms that you can reuse for other Monte Carlo simulations or other experimental data analysis problems.

The primary purpose of this case study is to convince you that modular programmingwill take you much further than you could getwithout it. Although no approach to programming is a panacea, the tools and approach that we have discussed in this section will allow you to attack complex programming tasks thatmight otherwise be far beyondyour reach.

The success of modular programming is only a start. Modern programmingsystems have avastly more flexible programming model thantheclass-as-a-library-of-fiinctions model that we have been considering. In the next two chapters, wedevelop this model, along withmanyexamples that illustrate its utility.


Q. Editing Visualize and Estimate to rename Percolation to PercolationEZor whatever methodwewant to studyseems to be a bother. Is there a way to avoiddoing so?

A. Yes, this is a keyissue to be revisited in Chapter 3. In the meantime, you cankeepthe implementations in separate subdirectories and usethe classpath, but thatcan get confusing. Advanced Java language mechanisms are also helpful, but theyalso have their own problems.

Q. That recursive flowO method makes me nervous. How can I better understand what it's doing?

A. Run it for smallexamples of your ownmaking, instrumentedwith instructionsto print a function call trace. After a few runs, you will gain confidence that it always fills the sites connected to the start point.

Q. Is there a simplenonrecursive approach?

A. There are several methods that perform the same basic computation. We willrevisit the problem at the end of the book, in Section 4.5. In the meantime, working on developing a nonrecursive implementation of flow() is certain to be aninstructive exercise, if you are interested.

Q. PrecPlot (Program 2.4.6) seems to involve a huge amountof calculation to geta simplefunction graph. Is there some better way?

A. Well, the best would be a mathematical proof of the threshold value, but thatderivation has eluded scientists.

307


2.4.1 Write a program that takes N from the command line and creates an N-by-Nmatrixwith the entry in rowi and columnj set to t rue if i andj are relativelyprime,then shows the matrixon the standarddrawing (see Exercise 1.4.13). Then,write a similar program to draw the Hadamard matrix of order N (see Exercise1.4.25) and the matrix suchwith the entry in rowN and columnj set to t rue if thecoefficient of a* in (l+x)N (binomial coefficient) is odd (see Exercise 1.4.33). Youmaybe surprised at the pattern formed by the latter.

2.4.2 Implement a pri nt () method for Percol ati on that prints 1 for blockedsites, 0 for open sites, and * for full sites.

2.4.3 Givethe recursive calls for Percol ati on given the following input:

3

0 1

0 0

1 0

2.4.4 Write a client of Percol ati on like Visual i ze that does a series of experiments for a value of N taken from the command line where the site vacancy probabilityp increases from 0 to 1by a givenincrement (also taken from the commandline).

2.4.5 Createa program Percol ati onDi rected that tests for directed percolation(by leaving off the last recursive call in the recursive show() method in Program2.4.5, as described in the text), then use PercPlot to draw a plot of the directedpercolation probabilityas a function of the sitevacancyprobability.

2.4.5 Write a client of Pe rcol ati on and Pe rcol ati onDi rected that takes a site

vacancyprobabilityp from the command line and prints an estimate of the probability that a system percolates but does not percolate down. Use enough experiments to get an estimate that is accurate to three decimal places.

2.4.6 Describe the order in which the sites are marked when Percolation is

used on a systemwith no blocked sites.Which is the last site marked? What is thedepth of the recursion?


2.4.7 Experimentwith using PercPl ot to plot variousmathematicalfunctions(justby replacing the call on Esti mate.eval () withan expression that evaluatesthefunction). Try thefunction si n(x) + cos(10*x) to see how theplotadapts toan oscillating curve, and comeup with interesting plotsfor three or four functionsof your own choosing.

2.4.8 Modify Percolati on to animate theflow computation, showing the sitesfilling onebyone.Check your answer to the previous exercise.

2.4.9 Modify Percolation to compute that maximum depth of the recursionused in the flow calculation. Plot theexpected value of thatquantity asa functionofthesite vacancy probabilityp. How does your answer change if theorder of therecursive calls is reversed?

2.4.10 Modify Estimate to produce output like that produced by Bernoulli(Program 2.2.6). Extra credit'. Use your program tovalidate thehypothesis that thedata obeys the Gaussian (normal) distribution.

309


Vreml^B^m^USs.

2.4.11 Verticalpercolation. Show thatasystem withsite vacancy probabilitypvertically percolates with probability 1- (1 - pN)N, anduse Esti mate tovalidate youranalysis for variousvalues of N.

2.4.12 Rectangular percolation systems. Modify the code in this section to allowyou to study percolation in rectangular systems. Compare the percolation probability plots of systems whose ratio ofwidth to height is 2 to 1with those whoseratio is 1 to 2.

2.4.13 Adaptive plotting. Modify PercPlot to take its control parameters (gaptolerance, error tolerance, and number of trials) from the command line. Experimentwithvarious values oftheparameters tolearn theireffect on thequality ofthecurve and the costof computing it. Briefly describe your findings.

2.4.14 Percolation threshold. Write a Percolation client that uses binary searchto estimate the threshold value (see Exercise 2.1.29).

2.4.15 Nonrecursive directedpercolation. Write a nonrecursive program that testsfor directed percolation bymoving from top to bottom as in ourvertical percolationcode. Base your solution onthefollowing computation: ifany site inacontiguous subrow of open sites in the current row is connected to some full site on theprevious row, thenall of thesites in thesubrow become full.

connected to top viaa pathoffilledsites thatnever goes up

not connected to top(bysuch a path)

connected to top

Directed percolation calculation


2.4.16 Fast percolation test. Modify the recursive flowO method in Program2.4.5 so that it returns as soon as it finds a site on the bottom row (and fillsno moresites). Hint. Use an argument done that is true if the bottom has been hit, f al seotherwise. Give a rough estimate of the performance improvement factor for thischange when running PercPlot. Use values of N for which the programs run atleasta few seconds but not morethan a few minutes. Note that the improvement isineffective unless the first recursive call in f 1ow() is for the site below the currentsite.

2.4.17 Bond percolation. Write a modular program for studying percolation undertheassumption that the edges of thegrid provide connectivity. Thatis, an edgecanbe eitheremptyor full, and a system percolates if thereis a path consisting offull edges that goes from top to bottom.Note: Thisproblem has been solved analytically, so your simulations should validate the hypothesis that the percolationthresholdapproaches 1/2asJV gets large.

2.4.19 Percolation in three dimensions. Implement a class Percol ati on3D anda class BooleanMatrix3D (for I/O and random generation) to study percolationin three-dimensional cubes, generalizing the two-dimensional case studied in thischapter. A percolation system is an AT-by-N-by-JV cubeof sites that are unit cubes,each open withprobabilityp andblocked with probability 1-p. Paths canconnectanopen cube with any open cube thatshares acommon face (one ofsix neighbors,except on the boundary). The system percolates if there exists a path connectinganyopensiteon the bottom planeto anyopensiteon the top plane. Use a recursiveversion of f1ow() like Program 2.4.5, but witheightrecursive calls insteadof four.Plot percolation probability versus site vacancy probability for as large a value ofN as you can. Be sure to develop your solution incrementally, as emphasizedthroughout this section.

2.4.18 Bond percolation on a triangular grid. Write a modular program forstudying bond percolation on a triangular grid, where thesystem iscomposedof 2N1 equilateral triangles packed together in an N-by-N grid of rhombusshapes. Each interior pointhas six bonds; each pointon theedge hasfour; andeach corner point has two.

311

does not

does not


2.4.20 Game oflife. Implement a class Li f e that simulates Conway's game oflife.Consider a boolean matrix corresponding to a system of cells that we refer to asbeingeitherlive or dead. Thegame consists of checking and perhapsupdatingthevalue of each cell, depending on the values of its neighbors (the adjacent cells inevery direction, including diagonals). Live cells remain live and deadcells remaindead, with the following exceptions:

• A dead cellwith exactly three live neighborsbecomeslive.• A live cellwith exactly one live neighbor becomesdead.• A livecellwith more than three liveneighbors becomes dead.

Initializewith a random matrix, or use one of the starting patterns on the booksite.Thisgame hasbeenheavily studied, andrelates to foundations of computerscience(see the booksite for more information).

HI eH mH pM\ We.time t timet+l time t+2 time t+3 time H-4

Five generations ofa glider

&^8^^^^^

3.1 Data Types 316

3.2 Creating Data Types 370

3.3 Designing Data Types 4163.4 Case Study: N-body Simulation . . . 456

Your next step to programming effectivelyis conceptuallysimple. Now that youknowhowto useprimitive types of data,youwill learn in this chapterhowto

use, create, and design higher-level data types.Anabstraction isa simplified description ofsomething that captures itsessen

tial elements while suppressing all otherdetails. In science, engineering, and programming, wearealways striving to understand complex systems through abstraction. In Java programming, wedo so with object-oriented programming, wherewebreaka large and potentially complex program into a set of interacting elements,or objects. The ideaoriginates from modeling (in software) real-world entitiessuchas electrons, people, buildings, or solar systems and readily extends to modelingabstract entities suchasbits,numbers, colors, images, or programs.

A data type is a set of values and a set of operationsdefinedon those values.Thevalues and operations for primitivetypessuchas i nt and double are built intothe Java language. In object-oriented programming, we write Java code to createnewdatatypes. Anobject isan entity thatcantake on a data-type value. Anobject'svalue canbe returned to a client or changed byoneof itsdata type's operations.

Thisability to define newdata types and to manipulate objects holdingdatatype values is also known as data abstraction, and leads us to a style of modularprogramming that naturally extends the function abstraction style for primitivetypes that was the basisfor Chapter 2.A data type allows us to isolatedata as wellas functions. Our mantra for thischapter is this: Whenever you can clearly separatedata andassociated tasks within a computation, you should doso.

315

Object-Oriented Programming

3a1 Data Types

Organizing data for processing is an essential step in the development of a computer program. Programming in Java is largely based on doing so with data typesknown as reference types that are designed to support object-oriented programming, a styleof programming that facilitatesorganizingand processingdata. 3.1.1 Charged particles 320

The eightprimitive data types (bool- 3.1.2 Albers squares .325ean, byte, char, double, float, int, long, 3*L3 Luminance library . . . .328

, , N . , , . 3.1.4 Converting color to grayscale. . . .331and short) that you have been using are 315 Imagescaling 333supplemented in Java by extensive libraries 3.1.6 Fade effect 335of reference types that are tailored for a large 3.1.7 Visualizing electric potential .... 337variety ofapplications. Stri ng is one exam- 3-1-8 Finding genes in agenome 342pie of such a type that you have used. You ' ' oncaena n8 es • • • • • • • • •r /r / 3.1.10 Screen scraping for stockquotes . . 349will learn more about the String data type 3#L11 splitting afile .350in this section, as well as how to use several n . .... '

. . Programs in thissectionother reference types for image processingand input/output. Some of them are builtinto Java (String and Color), and some were developed for this book (In, Out,Draw, and Pictu re) and are usefulas general resources, likethe Std* static methodlibraries that we introduced in Section 1.5.

You certainlynoticed in the first two chapters of this book that our programswere largely confined to operations on numbers. Of course, the reasonis that Java'sprimitive types represent numbers; however, with reference types you can writeprograms that operate on strings, pictures, sounds, or any of hundreds of otherabstractions that are available in Java's standard libraries or on the booksite.

Even more significant than this large library of predefined data types is theidea that the range of data types that are available to you in Javaprogramming isopen-ended,because you can define your own data types to implement anyabstraction whatsoever. This ability is crucial in modern programming. No library canmeet the needs of all possible applications, so programmers routinely build datatypes to meet their own needs.You willlearn how to do so in Section 3.2.

In this section, we focus on client programs that use data types, to give yousome concrete referencepoints for understanding these new concepts and to illustrate their broad reach. Wewill consider programs that manipulate colors, images,strings, files, and web pages—quite a leap from the primitive types of Chapter 1.

3.1 Data Types

Basic definitions. Adata type isa setofvalues anda setof operations definedon those values. This statement is one of several mantras that we repeat often because of its importance. In Chapter 1,we discussed in detail Java's primitive datatypes: for example, the values of the primitive data type i nt are integers between—231 and 231 —1; the operations of int are the basic arithmetic and comparisonoperations, including +, *, %, <, and >.You alsohavebeen using a data type that isnot primitive—the Stri ng data type. Your experience with using St ri ng demonstrates that you do not need to know howa data type is implemented in order to beable to use it (yet another mantra). You knowthat values of Stri ng are sequencesof charactersand that you can perform the operation of concatenatingtwo Stri ngvalues to produce a Stri ng result. Youwill learn in this section that there are dozens of other operations available for processing strings, such as finding a string'slength or extractinga substring. Every data type is defined by its set of values andthe operations defined on them, but whenwe use the data type, we focus on theoperations, not the values. When youwriteprogramsthat use i nt or Stri ngvalues,you are not concerning yourselfwith how they are represented (we never did spellout the details), and the sameholds true whenyou write programsthat use reference types such as Color and Pi cture.

317

Example. As a running example of how to use a data type, wewill consider a data type Charge for charged particles. In particular, we are interested in a two-dimensional model that uses

Coulomb's law, whichtells us that the electric potentialat a pointdueto a given charged particle isrepresented by V= kq Ir, where qis the charge value, r is the distance fromthe point to the charge,and fc=8.99X 109 Nm2/C2 is the electrostatic constant. For consis

tency, we use SI (Systeme International d'Unites): in this formula,N designates Newtons (force), m designates meters (distance),and C representcoulombs(electric charge). Whenthere are multiple charged particles, the electric potential at any point is thesum of the potentials due to eachcharge. Our interestiscomputing the potential at various points in the plane due to a given setof chargedparticles.Todo so,wewillwrite programs that define,create, and manipulatevariables of typeCharge. In Section3.2, you willlearn howto implement the data type, but you do notneed to know how a data type is implemented in order to be able to use it.

potential at (x, y)due to c is kq/r

(*,y)

(Wo>

charged particlecwith valueq

Coulomb's lawfor acharged particlein theplane

318 Object-Oriented Programming

API. The Java class provides a mechanism for defining data types. In a class, wespecify the data-type values and implement the data-type operations. In order tofulfill our promise that you do notneed toknow how a data type is implemented inorder tobeable touseit,we specifythe behavior of classes for clients by listing theirmethods in an API(application programming interface), in the same manner as wehavebeen doing for librariesof staticmethods.The purpose of an APIis to providethe information that you need to write programs using the data type. (In Section3.2,you willsee that the same information specifies the operations that you needto implement it.) For example, this APIspecifies our classCharge for writing programs that process charged particles:

public class Charge

Charge(double xO, double yO, double qO)

doubl e potenti al At (doubl e x, doubl e y) electric potential at (x, y) duetocharge

Stri ng toStri ng() string representation

APIfor charged particles

Thefirst entry, withthesame nameasthe class and no return type,defines a specialmethod known as a constructor. The other entries define instance methods that can

take arguments and returnvalues in thesame mannerasthe static methods that wehave beenusing, but theyarenot static methods: theyimplement operations forthedata type. Charge has two instance methods: The first is potential At(), whichcomputes and returns the potentialdue to the charge at the given point (x,y). Thesecond is toStri ng(), which returns a string that represents the charged particle.

Using a data type. As with libraries of static methods, the codethat implementseach class resides in a file that has the same name as the class but with a .Javaextension. To write a client program that uses Charge,you need access to the fileCharge. Java, either by having a copy in the current directory or by using Java'sclasspath mechanism (described in the booksite). With this understood, you willnext learn how to use a data type in your own client code.Todo so,you need to beable to declare variables, create objects to hold data-type values, and invoke methodsto manipulate these values. These processes are different from the correspondingprocesses for primitive types,though you willnotice many similarities.

3.1 Data Types 319

Declaring variables. You declare variables of a reference type in precisely the samewaythat you declarevariables of a primitive type, using a statement consisting ofthe data type name followedby a variable name. For example, the declaration

Charge c;

declares a variable c of type Charge. This statement does not create anything; it justsaysthat we will use the name c to refer to a Charge object.

Creating objects. In Java, each datatypevalue isstored in an object. Whena clientinvokes a constructor, the Java systemcreates (or instantiates) an individual object.Toinvoke a constructor, use the keyword new; followed by the class name; followedbythe constructor'sarguments, enclosed in parentheses and separatedby commas,in the same manner as a static method call. For example, new Charge(xO, yO,qO) createsa new Charge objectwith position (x0,y0) and chargeq0. Typically, client code invokes a constructor to createan object and assigns it to a variable in thesame line of code as the declaration:

Charge c = new Charge(0.51, 0.63, 21.3);

You can createany number of objects from the sameclass; eachobjecthas its ownidentity and may or may not store the same value as another object of the sametype. For example, the code

Charge cl = new Charge(0.51, 0.63, 21.3)Charge c2 = new Charge(0.13, 0.94, 85.9)Charge c3 = new Charge(0.51, 0.63, 21.3)

creates three different Charge objects. In particular, cl and c3 refer to differentobjects,even though the objects store the samevalue.

Invoking methods. The most important difference between a variable of a reference typeand a variable of a primitive typeis that youcanusereference typevariables to invoke the methods that implement data type operations (in contrast tothe built-in syntax involving operators such as + and * that we used for primitivetypes). Suchmethods are known as instance methods. Invokingan instance methodis similar to invoking a static method in another class, except that an instancemethod is associated not just with a class, but also with an individual object. Accordingly, we use an object name (variable of the given type) instead of the classname to identify the method. For example, if c is a variable of type Charge, then


o;:',^^

Program 3.1.1 Charged particles

public class Charged ient{

public static void main(String[] args){ // Print total potential at (x, y).

double x = Double.parseDouble(args[0]);double y = Double.parseDouble(args[l]);Charge cl = new Charge(.51, .63, 21.3);Charge c2 = new Charge(.13, .94, 81.9);double vl = cl.potentia!At(x, y);double v2 = c2.potentialAt(x, y);StdOut.pri ntf("%.le\n", vl+v2);

}}

x, y

cl

vl

c2

v2

querypoint

first charge

potentialdue to cl

second charge

potential due tool

This object-oriented client takes a query point (x, y) as command-line argument, creates twocharges cl and c2 with fixed position and electric charge, and uses the potential At() instance method in Charge tocompute the potential at (x, y) dueto the two charges.

% Java Chargedient .2 .52.2e+12

% Java Chargedient .51 .942.5e+12

>!

c.potentialAt(x, y) re

turns a double value that

represents the potentialat (x,y) due to the charge q0 at (x0,y0). The values x and y belong to the client, the valuesKm Vm and cin belonc to the ^^^^^^^^^^ffi^^^RH^^H^^^^^^^^^^^^^^SRI^^^^'

object. For example, Charged ient (Program 3.1.1) creates two Charge objectsand computes the total potential at a query point taken from the command linedue to the two charges. This codeclearly exhibitsthe ideaof developing an abstractmodel and separating the code that implements the abstraction from the code thatuses it. This ability characterizes object-oriented programming and is a turning

i|PjSjfiffi3§$5^^k

charged particle c2with value 81.9

(.13, .94)(.38

.45 *

potentialat thispoint is8.99xl09(21.3/.31+81.9/.38)

/ = 2.5xl012

--f(.51,.94)

•31

,(.51,-63)

(•2,.5)W-

tpotentialat thispoint is

8.99xl09(21.3/.34+81.9/.45)

= 2.2xl012

.34 charged particle cl

with value 21.3

3.1 Data Types 321

point in this book: we have not yet seen any code of this nature, but virtually all ofthe code that we write from this point forward willbe based on defining and invoking methods that implement data types operations.

References. Aconstructor creates anobject andreturns to theclient areference to the object, not the object itself (hence the name referencetype). What is a reference? Nothing more than a mechanism for accessing an object. There are several different ways for Java to implementreferences, but we do not need to know the details in order to usethem. Still, it is worthwhile to have a mental model of one common

implementation. One approach is for new to assign memory space tohold the object'scurrent data type valueand return apointer (machine

address) to that space. We re-declare a variable (object name)

invoke a constructor to createan object

/Charge cl;

cl =|new Charge(.51, .63, 21.3)

double v =[[c/

object name

potentialAt(x, y)

\invoke an instance method

thatoperates on theobject's value

Using a reference data type

fer to the memory space associated with the object as theobject's identity. Why not justprocess the object itself? Forsmall objects, it might makesense to do so, but for largeobjects, cost becomes an issue:data-type values can be complicated and consume largeamounts of memory. It doesnot make sense to copy or

move all of its data every time that we pass an object as an argumentto a method. If this reasoning seems familiar to you, it is because wehave used precisely the same reasoning before, when talking aboutpassing arrays as arguments to static methods in Section 2.1. Indeed,arraysare objects,aswewillseelater in this section.Bycontrast, primitivetypeshavevalues that are natural to represent directly in memoryand operations that translate directlyto machineoperations,so that itdoes not make sense to use a reference to access each value. We will

discuss references in more detail after you have seen severalexamplesof clientcodethat usesreference types. Your Java system might usesomething morecomplicated than machine addresses to implement references, but this model captures the essential differencebetween primitive and referencetypes.

one object

1 Ireference

cl 459

459 .51 Lt— positioi460 .63

461 21.3 -<—charge

1

two objects

1

cl 459

c2 611

identity

isofcl459 .51

460 .63

461 21.3

identityy «f&

611 .13

612 .94

613 81.9

1 1

Object representation


Using objects. A declaration give us a variable name for an objectthat wecan usein code in much the same wayas we use a variable name for an integer or floatingpoint number:

• As an argument or return value for a method• In an assignment statement• In an array

Wehavebeen using Stri ngobjects in this wayeversinceHel 1oWorl d:most of ourprograms call StdOut. pri ntl n() with a String argument, and all of our programs have a mai n() method that takes an argument that is an array of Stri ngobjects. Aswe have alreadyseen, there is one criticallyimportant addition to thislist for variables that refer to objects:

• To invoke an instance method defined on it

This usageis not available for variables of a primitivetype,where alloperations arebuilt into the language and invoked usingoperators such as +, -, *, and /.

Type conversion. If you want to convert an object from one type to another,youhave to write code to do it. Often, there is no issue, because values for different datatypes aresodifferent that no conversion iscontemplated. Forinstance, whatwouldit mean to convert a Charge to a Color? But you have already seen one casewhereconversion is worthwhile: all Java reference types have a method toStri ng() thatreturns a String. Moreover, Java automatically calls this method for any objectwhen a Stri ng is expected. One consequence of this conventionis that it enablesyou to write StdOut.pri ntl n(x) for anyvariable x. Forexample, adding the callStdOut. pri ntl n(cl); to Charged ient would add charge 21.3 at (0.51,0.63) to the output. The nature of the conversion is completely up to the implementation, but usually the string encodes the object's value.

Uninitialized variables. When you declare a variable of a reference type but donot assign a value to it, the variable is uninitialized, which leads to the samebehavior as for primitive typeswhenyou try to usethe variable. For example, the code

Charge bad;double v = bad.potentialAt(.5, .5);

willnot compile, because it is trying to usean uninitializedvariable,which leadstothe error variable bad might not have been initialized.

3.1 Data Types

Distinction between instance methods andstatic methods. Finally, youarereadyto appreciate the meaning of the keyword stati c that we have been using sinceProgram 1.1,one of the last mysterious details in the Javaprograms that you havebeen writing. The primary purpose of static methods is to implement functions;the primary purpose of non-static (instance) methods is to implement data-typeoperations. You can distinguish between the uses of the two types of methods inour client code, because a static method call always starts with a class name (uppercase, by convention) and a non-static method call always starts with an objectname (lowercase, by convention). These differences are summarized in the following table, but after you have written some client code yourself, you will be able toquickly recognize the difference.

instance method static method

samplecall cl.potentialAt(x, y) Math.sqrt(2.0)

invoked with object name class name

parameters reference to object and argument(s) argument(s)

primarypurpose manipulate object value compute return value

Instance methods vs. static methods

The basic concepts that we have just covered are the starting point for object-oriented programming, so it is worthwhile to briefly summarize them:A data type isa set of values and a set of operations definedon those values. Weimplement datatypes in independent modules and write clientprogramsthat use them. An objectis an instance of a data type. Objectsare characterized by three essential properties:state, behavior, and identity. Thestate of an object isa value fromits data type.Thebehavior of an object is defined by the data type's operations. The identity of anobject is the place where it is storedin memory. In object-oriented programming,we invoke constructors to create objects and then modify their state by invokingtheir instance methods.

To demonstrate the power of object orientation, we next consider severalmore examples. First,weconsider the familiarworldof imageprocessing, whereweprocess Color and Picture objects. Then, we consider the operations associatedwith Stri ng objects and their importance in a scientific application.

323


Color. Color is a sensation in the eye from electromagnetic radiation. Since wewant to viewand manipulatecolorimages on our computers,color is a widelyusedabstraction in computer graphics, and Java provides a Color data type. In professional publishing in print and on the web,working with color is a complex task. Forexample, the appearance of a color image depends in a significant way on the medium used to present it. The Color data type separates the creative designer's problem of specifying a desired color from the system's problem of faithfully reproducing it.

Java has hundreds of data types in its libraries, so we need to explicitly listwhich Javalibraries we are using in our program to avoid naming conflicts.Specifically, we include the statement

import Java.awt.Color;

at the beginning of any program that uses Color. (Until now,we have been using standard Java libraries or our own, sothere has been no need to import them.)

To represent color values, Color uses the RGB systemwhere a color is defined by three integers (each between 0 and255) that represent the intensity of the red, green, and blue(respectively) components of the color. Other color valuesare obtained by mixing the red, green, and blue components.That is, the data type values of Color are three 8-bit integers.We do not need to know whether the implementation usesi nt, short, or char values to represent these integers. Withthis convention, Java is using 24 bits to represent each colorand can represent 2563 = 224 ~ 16.7 million possiblecolors.Scientists estimate thatthe human eyecan distinguishonly about 10million distinct colors.

Color has a constructor that takes three integer arguments, so that you canwrite, for example

Color red = new Color(255, 0, 0);Color bookBlue = new Col or( 9, 90, 166);

to create objects whose values represent red and the blue used to print this book,respectively. Wehavebeen usingcolorsin StdDraw sinceSection 1.5,but havebeenlimited to a set of predefined colors, such as StdDraw. BLACK, StdDraw. RED, andStdDraw. PINK. Now you have millions of available colors. AlbersSquares (Program 3.1.2) is a StdDraw client that allowsyou to experiment with them.

red green blue

255 0 0 red

0 255 0 green

0 0 255 blue

0 0 0 black

100 100 100 darkgray

255 255 255 white

255 255 0 yellow

255 0 255 magenta

9 90 166 this color

Some color values

3.7 Data Types 325

"• «My'f, - aft v^ * * / , y ymm ^ *t a. x .^vrJ&L&JL!!^

if

lia

11

1HSi

Program 3.J.2 Alberssquares

import java.awt.Color;

public class AlbersSquares{

public static void main(String[] args){ // Display Albers squares for the two RGB

// colors entered on the command line,int rl = Integer.parselnt(args[0]);int gl = Integer.parselnt(args[1]);int bl = Integer.parselnt(args[2]);Color cl = new Color(rl, gl, bl);

int r2 = Integer.parselnt(args[3]);int g2 = Integer.parselnt(args[4]);int b2 = Integer.parselnt(args[5]);Color c2 = new Color(r2, g2, b2);

}

StdDraw.setPenColor(cl);StdDraw.filledSquare(.25, .5, .2);StdDraw.setPenColor(c2);StdDraw.filledSquare(.25, .5, .1);StdDraw.setPenColor(c2);StdDraw.filledSquare(.75, .5, .2);StdDraw.setPenColor(cl);StdDraw.filledSquare(.75, .5, .1);

a *-~ ^ ,£&!j&»*i ~_

rl, gl, bl

cl

r2, g2, b2

c2

This program displays the two colors entered in RGB representation on the command line inthefamiliarformat developed in the 1960s by the color theorist JosefAlbers that revolutionizedtheway thatpeople think aboutcolor.

^^^^^Wftl^^

Java AlbersSquares 9 90 166 100 100 100

,mmww'f^mMMmmmmm


Asusual, when we address a new abstraction, we are introducing you to Colorby describingthe essentialelementsof Java's color model, not all of the details.TheAPI for Col or contains several constructors and over 20 methods; the ones that we

will use are briefly summarized next.

public class java.awt.Color

Color(int r, int g, int b)

i nt getRed () red intensity

i nt getGreen () green intensity

i nt getBl ue () blue intensity

Col or bri ghte r () brighter version ofthis color

Col Or darke r () darker version of thiscolor

St ri ng toSt ri ng () string representation ofthis color

bool ean equal S(Col or c) is this color's value the same ascs.?

Seeonline documentation and booksitefor other available methods.

Excerptsfrom the APIforJavas Color datatype

Our primary purpose is to use Color as an example to illustrate object-orientedprogramming, while at the sametime developing a few useful toolsthat wecan useto writeprogramsthat process colors. Accordingly, wechoose one colorproperty asan example to convince you that writing object-oriented code to process abstractconceptslikecolor is a convenientand usefulapproach

Luminance. Thequality of the images on moderndisplays suchasLCD monitors,plasmaTVs, and cellphone screens depends on an understandingof a color property known as monochrome luminance, or effective brightness. A standard formulafor luminance is derived from the eye's sensitivity to red, green, and blue. It is alinear combination of the three intensities: if a color's red, green, and blue valuesare r,g, and b, respectively, then its luminance is definedby this equation:

Y= 0.299r + 0.587g+ 0.114b

Since the coefficients are positive and sum to 1 and the intensities are all integersbetween 0 and 255, the luminance is a real number between 0 and 255.

3.1 Data Types

Grayscale. The RGB system has the propertythat when all three colorintensitiesare the same, the resulting color is on a grayscale that ranges from black (all Os) towhite (all 255s).Toprint a color photograph in a black-and-white newspaper (or abook), we need a static method to convert from color to grayscale. A simple waytoconvert a color to grayscale is to replace the colorwith a new one whose red, green,and blue values equal its monochrome luminance.

Color compatibility. Theluminance value is also crucial in determining whethertwo colors are compatible, in the sense that printing text in one of the colors on abackground in the other color willbe readable. Awidelyused rule of thumb is that

the difference between the luminance of the

foreground and background colors should be atleast 128. For example, black text on a whitebackground has a luminance difference of 255,but black text on a (book) blue background hasa luminance difference of only 74. This rule isimportant in the design of advertising, roadsigns, websites, and many other applications.Luminance (Program 3.1.3) is a static methodlibrarythat wecanuseto converta colorto grayscale and to testwhethertwo colorsare compatible,for example, when weusecolors in StdDraw

applications. Themethods in Lumi nance illustrate the utility of using data types toorganize information. Using the Color reference type and passing objects as argumentsmakes these implementations substantiallysimpler than the alternative of having to passaround the three intensity values. Returningmultiple values from a function also would beproblematic without reference types.

red

9

green

90

blue

166 this color

74 74 74 grayscale version

black

0.299*9 + 0.587*90 + 0.114* 166= 74.445

Grayscale example

luminance

74

232

Having an abstraction for color is importantnot just for direct use, but also in buildinghigher-level data types that have Color values. Next, we illustrate this point bybuilding on the color abstraction to develop a data type that allows us to writeprograms to process digital images.

compatible

Compatibility example

327

difference

232

158

74


^»»^§f^

Program 3.1.3 Luminance library


public class Luminance{

public static double lum(Color color){ // Compute luminance of color.

int r = color.getRedO;int g = color.getCreenO;int b = color.getBlueO;return .299*r + .587*g + .114*b;

}

public static Color toGray(Color color){ // Use luminance to convert to grayscale.

int y = (int) Math.round(lum(color));Color gray = new Color(y, y, y);return gray;

}

public static boolean compatible(Color a, Color b){ // Print true if colors are compatible, false otherwise,

return Math.abs(lum(a) - lum(b)) >= 128;

}

public static void main(String[] args){ // Are the two given RGB colors compatible?

int[] a = new int[6];for (int i = 0; i < 6; i++)

a[i] = Integer.parselnt(args[i]);Color cl = new Color(a[0], a[l], a[2]);Color c2 = new Color(a[3], a[4], a[5]);StdOut.println(compatible(cl, c2));

}

a[]

cl

c2

i nt valuesof args

first color

second color

fH This library comprises three important functions for manipulating color: luminance, conversion togray, and background/foreground compatibility.

Java Luminance 232 232 232true

% Java Luminance 9 90 166 232 232 232true

% Java Luminance 9 90 166 0 0 0false

mmmmmmm ^^^•^^^m^^j^^^^^^^^^^^S^*

r

3.1 Data Types

Digital image processing You are familiar with the concept of aphotograph.Technically, we might definea photograph as a two-dimensional imagecreatedbycollecting and focusing visible wavelengths of electromagnetic radiation that constitutes a representation of a scene at a point in time. That technical definition isbeyond our scope, except to note that the historyof photography is a history oftechnological development. During the last century, photography was based onchemical processes, but its future is now based in computation. Your camera andyour cellphone are computers with lenses and light-sensitive devices capable ofcapturing images in digital form, and your computer has photo-editing softwarethat allows you to process those images. You can crop them, enlarge and reducethem, adjust the contrast,brighten or darkenthem, remove redeye, or performscores ofotheroperations. Many such operationsare remarkably easy to implement, given a simple basic datatypethat captures the ideaof a digital image, asyouwill nowsee.

Digital images. We have been using StdDraw toplot geometric rowyobjects (points, lines, circles, squares) in a window on the computer screen. Which set of values do we need to process digitalimages, and which operations do we need to perform on thosevalues? The basic abstraction for computer displays is the sameone that is used for digital photographs and is very simple: Adigital image is a rectangular grid of pixels (picture elements),where the color of each pixel is individually defined. Digital images are sometimes referred to as raster or bitmapped images, incontrast to the types of images weproducewith StdDraw, whichare referredto as vector images.

Our class Picture is a data type for digital images whosedefinition follows immediately from thedigital image abstraction. Thesetofvaluesis nothing more than a two-dimensional matrix of Color values, and the operations are what you might expect: create an image (either a blank one with a givenwidth andheight or one initialized from a picture file), set the value ofa pixel to agiven color, returnthe color of a given pixel, return thewidth or the height, showthe image in a window on your computer screen, and save the image to a file. Inthis description, we intentionally use the word matrix instead ofarray toemphasizethatwe are referring toanabstraction (amatrix ofpixels), notaspecific implementation (a Java two-dimensional array of Color objects). You do notneed to know

pixel0,0

\

column x

width •

329

pixelsarereferences tocolor values

Anatomy ofa digitalimage


howa class is implemented in order tobeable touseit. Indeed, typical imageshavesomany pixels that implementations are likely to use a more efficientrepresentationthan an array of Color values (see Exercise 3.1.29). Such considerations are interesting,but can be dealt with independent of client code. Towrite client programsthat manipulate images,you just need to know this API:

public class Picture

PiCture(Stri ng f i 1ename) create apicturefrom afile

Pi CtU re (i nt W, i nt h) create a blank w-fry-h picture

i nt wi dth () return thewidth of thepicture

i nt hei ght () return the height of the picture

Color get (int X, int y) return the color ofpixel (x,y)

void set (int x, int y, Color c) setthe color ofpixel (x,y) toe

voi d show() display theimage in a window

void save(String filename) save the image to afile

APIfor ourdata type for image processing

By convention, (0,0) is the upper leftmost pixel, so the image is laidas in the customary order for arrays (by contrast, the convention for StdDraw is to have thepoint (0,0) at the lower left corner, sothatdrawings areoriented asin the customarymanner for Cartesian coordinates). Most image processing programs are filtersthat scan through the pixels in a source image as theywould a two-dimensionalarray andthenperform some computation to determine the color of each pixel ina target image. Thesupported file formats for the first constructor and the save()method arethe widely used . png and . j pgformats, so that you canwriteprogramsto process yourown photographs andaddtheresults to an album or awebsite. Theshow() window also has an interactive option for savingto a file. These methods,togetherwith Java's Col or data type,open the door to image processing.

Grayscale. You will find many examples ofcolor images onthebooksite, andall ofthe methods that we describeare effective for full-colorimages,but allour exampleimages in the textwillbe grayscale. Accordingly, our first task is to write a programthat can convertimages from color to grayscale. This task is a prototypicalimage-

3.1 Data Types

J^^^^i^^^»li^^^^^#SS^^^^M^j§^^

Program 3.1A Convertingcolor tograyscale


public class Grayscale{

public static void main(String[] args){ // Show image in grayscale.

Picture pic = new Picture(args[0]);for (int x = 0; x < pic.width(); x++){

for (int y = 0; y < pic.height(); y++){

Color color = pic.get(x, y);Color gray = Luminance.toGray(color);pic.set(x, y, gray);

}}pic.show();

}

331

pic image fromfile

x, y pixel coordinates

color pixel color

gray pixelgrayscale

This program illustrates a simple image processing client. First, it creates a Picture objectinitialized with an image file named by the command-line argument. Then it converts eachpixel in the image to grayscale by creating agrayscale version ofeach pixel's color and resetting the pixel to that color. Finally, itshows the image. You can perceive individual pixels inthe image on the right, which was upscaledfrom a low-resolution image (see "Scaling' on thenextpage).

--J j? •'•''•'•*••:?]% Java Grayscale mandrill.jpg % Java Grayscale darwin.jpg

I

^^SmB& ^^P^^^^^^^^^^^^^^P^^^^^^^^e


processing task: for each pixel in the source, we have a pixel in the target with adifferent color. Grayscal e (Program 3.1.4) is a filter that takes a file name from thecommand line and produces a grayscale version of that image. It creates a new Pi c-

ture object initialized with the color image, then sets the color ofeach pixelto a new Col or having a grayscale value computed by applying the toGrayO method in Luminance (Program 3.1.3) to thecolor of the corresponding pixel in the source.

downscalingsource

i!?!i

target

Iupscaling

Itarget

Scaling a digital image

Scaling. One of the most common image-processing tasks is tomake an image smaller or larger. Examples of this basic operation,known as scaling, include making small thumbnailphotos for use ina chat room or a cellphone, changing the size of a high-resolutionphoto to make it fit into a specific space in a printed publication oron a webpage, or zooming in on a satellite photograph or an imageproduced by a microscope. In optical systems, we can just move alens to achieve a desiredscale, but in digital imagery, we have to domore work.

In some cases, the strategyis clear. For example,if the target image is to be halfthe size (in each dimension) of the source image, wesimply choose halfthe pixels, say, bydeleting halfthe rows and halfthe columns. Thistechnique isknownassampling. If the target imageis to be double the size (in each dimension) of the source image, wecan replace each source pixel by four target pixels of the same color.Note that we can lose information when we downscale, so halvingan image and then doubling it generally does not give backthe sameimage.

A single strategy is effective for both downscaling and upscaling. Our goal is to produce the target image, sowe proceed throughthe pixels in the target, onebyone, scaling each pixel's coordinates toidentify a pixel in the source whose color canbe assigned to the target. If thewidth andheight of the source are ws and hs (respectively)and the width and height of the target are wt and ht (respectively),then wescale the column indexby ws/wt and the row index by hs/ht.

That is, we getthe color of the pixel in row y and column x of the targetfrom rowyXhs/ht andcolumn xXws/wt in thesource. Forexample, ifwe arehalving thesizeof a picture, the scale factors are2,sothe pixel in row2 and column 3 of the target

3.1 Data Types 333

fy-:fav:.v^%y*£^mW

."•••'y

i

Program 3.1.5 Image scaling

public class Scale{

public static void main (Stri ng[] args){

int w = Integer.parselnt(args[1]);int h = Integer.parselnt(args[2]);Picture source = new Picture(args[0]);Picture target = new Picture(w, h);for (int tx = 0; tx < w; tx++){

for (int ty = 0; ty < h; ty++){

int sx = tx * source.width() / w;int sy = ty * source.height() / h;target.set(tx, ty, source.get(sx, sy));

}}source.show();target.show();

}}

w, h

source

target

tx, ty

sx, sy

m

target dimensions

source image

targetimage

targetpixel coords

source pixel coords

This program takes the name ofa picture file and two integers (width wand height h) as %::command-line arguments and scales the image to w-fcy-h.

.•;•'••••.'•:':'".'

Java Scale mandrill.jpg 800 800


gets the color of the pixel in row 4 and column 6 of the source; if we are doublingthe size of the picture, the scalefactors are 1/2, so the pixel in row 6 and column 4of the target gets the color of the pixelin row 3 and column 2 of the source. Seal e(Program 3.1.5) is an implementation of this strategy. More sophisticated strate

gies canbe effective for low-resolution imagesof the sortthat you might find on old web pagesor from old cameras. For example, we might downscale to half size byaveraging the values of four pixels in the source to makeone pixel in the target. For the high-resolution imagesthat are common in most applications today, the simpleapproach used in Seal e is effective.

The same basic idea of computing the color valueof each target pixel as a function of the color values ofspecific source pixels is effective for all sorts of image-processing tasks. Next, we consider two more examples,and you willfind numerous other examples in the exercises and on the booksite.

Java Fade mandrill.jpg Darwin.jpg 9

Fade effect. Our next image-processing example is anentertaining computation where we transform one image to another in a series of discrete steps. Such a transformation is sometimes known as a fade effect. Fade(Program 3.1.6) is a Picture and Color client that usesa linear interpolation strategy to implement this effect.It computes Af—1 intermediate images, with each pixelin the tth image a weighted average of the corresponding pixels in the source and target. The static methodblendO implements the interpolation: the sourcecoloris weighted by a factor of 1 - 11M and the target colorby a factoroft/M (when t is 0,we havethe source color,and when t is M, we have the target color). This simple

computationcan producestriking results. Whenyou run Fadeon your computer,the change appears to happen dynamically. Try running it on some images fromyour photo library. Note that Fade assumes that the images have the same widthand height; if you haveimages for which this is not the case, you can use Seal e tocreated a scaled version of one or both of them for Fade.

3.1 Data Types

^^^^M^^^J^iMi

Program 3.1.6 Fade effect


public class Fade{

public static Color blend(Color c, Color d, double alpha){ // Compute blend of c and d, weighted by x.

double r = (l-alpha)*c.getRed() + alpha*d.getRed();double g = (l-alpha)*c.getGreen() + alpha*d.getGreen();double b = (l-alpha)*c.getBlue() + alpha*d.getBlue();return new Color((int) r, (int) g, (int) b);

}public static void main(String[] args){ // Show M-image fade sequence from source to target.

Picture source = new Picture(args[0]);Picture target = new Picture(args[l]);int M = Integer.parselnt(args[2]);int width = source.width();int height = source.height();Picture pic = new Picture(width, height);for (int t = 0; t <= M; t++){

for (int x = 0; x < width; x++){

for (int y = 0; y < height; y++){

Color cO = source.get(x, y);Color cM = target.get(x, y);Color c = blend(c0, cM, (double) t/M);pic.set(x, y, c);

}}pic.showQ;

335

M

pic

t

cO

cl

number of images

currentimage

imagecounter

source color

target color

blended color

}

To fadefrom one image into another in Msteps, we set each pixel in the tth image to aweightedaverage ofthe corresponding pixel in the source and the destination, with the source gettingweight 1-t/Mand the destination getting weight t/M. An example transformation is shown onthefacingpage.


Potentialvaluevisualization. Imageprocessing is alsohelpful in scientific visualization.As an example, we considera Picture client for visualizing properties ofthe Charge data type that we introduced at the beginning of this chapter. Poten-tial (Program 3.1.7) visualizes the potential values created by a set of chargedparticles. First, Potenti al creates an array of particles, with values taken fromstandardinput. Next, it creates a Picture object and sets eachpixel in the pictureto a shade of gray that is proportional to the potential value at the correspondingpoint.Thecalculation at the heartof the methodisverysimple: for each pixel, wecompute corresponding (x,y) values in the unit square, then call potential At()to find the potential at that point due to allof the charges, summingthe values re

turned. With appropriate assignment of potential values to grayscale values (scaling them tofallbetween0 and 255),we get a striking visual

-100 ^^^^^^^^^^^M representation of the electric potential that is40 ^^^^^B^HRf!! an excellent aid to understanding interactions10 ^^^^^|^^^g|fl among such particles. We could produce asim-5 ^^^^H^^H^H ilar image using filledSquare() in StdDraw,

but Picture provides us with more accuratecontrol over the color of each pixel on thescreen. The same basic method is useful in

manyother settings—you can find several ex-ampleson the booksite.

Potential value visualization for a setofcharges It is worthwhile to reflect briefly on the code

in Potential, because it exemplifies data abstraction and object-oriented programming.

We want to produce an image that shows interactions among charged particles,and our codereflects precisely the process of creating that image, usinga Pictureobject for the image (which is manipulated via Color objects) and Charge objectsfortheparticles. When we want information abouta Charge, we invoke theappropriate method directly for that Charge; whenwewant to createa Color, we use aCol or constructor;whenwewant to set a pixel, wedirectlyinvolve the appropriatemethodfor the Picture. These data types are independently developed, but theiruse together in a single client is easy and natural. We next consider several moreexamples, to illustrate the broad reach of data abstraction while at the same timeadding a numberof useful datatypes to our basic programming model.

3.1 Data Types 337

!$!

ill

«

*gg$ij§£'^^^^^^^^^^^^^^^^^^^^t^^^^^^^^^^^^^^^i

Program 3.1.7 Visualizing electricpotential

import Java.awt.Col or;

public class Potential{

public static void main(String[] args){ // Read charges from Stdin into a[].

int N = Stdin.readlnt();Charged a = new Charge[N];for (int k = 0; k < N; k++){

double xO = Stdin.readDouble();double yO = Stdin. readDoubleO;double qO = Stdin. readDoubleO;a[k] = new Charge(xO, yO, qO);

// Create and show image depicting potential valuesint size = 512;Picture pic = new Picture(size, size);for (int i = 0; i < size; i++){

for (int j = 0; j < size; j++){ // Compute pixel color.

double x = (double) i / size;double y = (double) j / size;double V = 0.0;for (int k = 0; k < N; k++)

V += a[k].potentialAt(x, y);int g - 128 + (int) (V / 2.0el0);if (g < 0) g = 0;if (g > 255) g = 255;Color c = new Color(g, g, g);pic.set(i, size-l-j, c);

}

}pic.showQ;

N

a[]

xO, yO

qO

number of charges

array of charges

charge position

charge value

x,

pixelposition

point in unitsquare

scaledpotential value

pixel color

This program reads valuesfrom standard input to create an array ofchargedparticles, sets eachpixel color in an image to agrayscale value proportional to the total ofthe potentials due to theparticles atcorresponding points, and shows the resulting image.


String processing You have been using strings since your first Java program.Java's Stri ng data type includesa long list of other operations on strings. It is oneof Java's most important data types because string processing is critical to manycomputational applications. Strings lie at the heart of our ability to compile andrun Java programs and to perform many other core computations; they are thebasis of the information-processing systems that are critical to most businesssystems; people usethemevery daywhen typing into email, blog, or chatapplicationsor preparing documents forpublication; andtheyhave proven to be critical ingredientsin scientific progress in several fields, particularly molecular biology.

A String value is an indexedsequence of char values. We summarize herethe methods from the JavaAPI that we use most often. Several of the methods useintegers to refer to a character's index within a string; as with arrays, these indicesstart at 0. As indicated in the note at the bottom, this list is a small subset of theStri ng API; the full API has over 60 methods!

public class String (Javastring data type)

String(String s)

int length()

char charAt(int i)

String substring(int i, int j)

boolean contains(String sub)

boolean startsWith(String pre)

boolean endsWith(String post)

int indexOf(String p)

int indexOf(String p, int i)

String concat(String t)

int compareTo(String t)

String replaceAll(String a, String b)

String[] split (String delim)

boolean equals(String t)

create a string with thesame value as s

stringlength

i th character

i th through (j -l)st characters

does string contain sub asa substring?

does string start withpre?

does stringend withpost?

index offirstoccurrence ofp

index offirstoccurrence ofp after i

this string with t appended

stringcomparison

result of changing as to bs

strings between occurrences o/del i m

is this string's value thesameas t's?

See online documentation andbooksiteformany other available methods.

Excerpts from the APIforJava s Stri ng data type

3.1 Data Types

Java provides special language support for manipulating strings. Instead ofinitializing a string with a constructor, we can use a string literal, and instead ofinvoking the method concat (), wecan usethe +operator:

shorthand String s = "abc";

longhand String s = new String("abc");String t = r + s;

String t = r.concat(s);

These notationsareshorthand for standarddata-type mechanisms.Stri ngvalues are not the sameasarrays of characters, but the two are similar,

and novice Java programmers sometimes confuse them. For example, the differences are evident in one of the most common code idioms for both strings andarrays: for loops to process each element (for arrays) or character (forstrings):

for (int i = 0; i < a.length; i++){ ... a[i] ... }

array

for (int i = 0; i < s.length(); i++){ ... s.charAt(i) ... }

string

For arrays, we have direct language support: brackets for indexed access and.length (with no parentheses) for length. For strings, both indexed access andlength are just Stri ng methods.

The split() method in the String API is powerful because many options,known as regular expressions, are available for delim. For example, "\\s+" means"one or morewhitespace characters." Using thisdelimiter with split () transformsa string of words delimitedbywhitespace into an arrayof words.

Why not just use arrays of characters instead ofString values? When we process strings, we want towrite client code that operates on strings, not arrays.The methods in Java's String data type implementnatural operations on String values and also simplifyclient code, as you will see. We have been working withprograms that use a few short strings for output, but itis not unusual for strings, not numbers, to be the primarydata type of interestin an application, and to haveprograms that process hugestrings or hugenumbers ofstrings. Next, we consider in detail such an application. Examples ofstring operations

339

String a = "now is»

String b = "the time ";String c = "to"

call value

a.length() 7

a.charAt(4) i

a.substring(2, 5) "w i"

startsWith("the") true

a.index0f("is") 4

a.concat(c) "now is to

.replaceCtVT') "The Time

a.split(" ")[0] "now"

a.splitC ")[1] "is"

b.equals(c) false

340

is thestringa palindrome?

extractfile nameand extension from a

command-line

argument

printall linesonstandard input that

contain a stringspecified fromacommand line

argument

create an arrayof thestrings onstandard input

delimited by whitespace

check whetheran arrayofstrings is in

alphabetical order

printall thehyperlinks(to educational institutions) of thestrings on

standard input


public static boolean isPalindrome(String s){

int N = s.lengthO;for (int i = 0; i < N/2; i++)

if (s.charAt(i) != s.charAt(N-l-i))return false;

return true;

}

String s = args[0];int dot = s.indexOf(".");String base = s.substring(0, dot);String extension = s. substring(dot + 1, s.lengthO);

String query = args[0];while (! Stdin. isEmptyO){

String s = Stdin.readLineO;if (s.contains(query)) StdOut.println(s);

}

String input = Stdin.readAHO;String[] words = input.split("\\s+");

public boolean isSorted(String[] a){

for (int i = 1; i < a.length; i++){

if (a[i-l].compareTo(a[i]) > 0)return false;

}return true;

}

while (!Stdin.isEmptyO){

String s = Stdln.readStringO;if (s.startsWithC'http://") && s.endsWith(".edu"))

StdOut.println(s);

}

Typical string-processing code

3.1 Data Types 341

String-processingapplication: genomics To give you more experience withstring processing, we will give a very briefoverview of the field of genomics andconsider a Java program thatsolves abasic problem known asgenefinding. Genomics is a quintessentialstring-processing application.

Biologists usea simple modelto represent the building blocks of life: ThelettersA, C, T, and Grepresent the fournucleotides in the DNA of living organisms. Ineach living organism, these basic building blocks appear in a set of long sequences(one for eachchromosome) knownasa genome. Scientists knowthat understandingproperties of the genome is a key to understanding the processes that manifestthemselves in living organisms. The genomic sequences for many living things areknown, including a human genome, which is a sequence of about three billioncharacters. You can find these sequences in many places on the web. (We have collected severalon the booksite: for instance, the file genomeVi rus. txt, which is the6252-character genome of a simple virus.) Knowing the sequences, scientists arenow writing computer programs to study thestructure of these sequences. Stringprocessing is now one of the most important methodologies—experimental orcomputational—in molecular biology forelucidating biological function.

Gene finding. Agene isa substring ofa genome that represents a functional unitofcritical importance in understanding life processes. Genes are substrings of thegenome ofvarying length, andthere are varying numbers ofthem within agenome.Agene isa sequence of codons, each ofwhich isa nucleotide triplet that representsoneamino acid. The start codon ATG marks thebeginning ofa gene, andany of thestop codons TAG, TAA, or TGA mark the end of a gene (and thereareno occurrencesofany ofthe codons ATG, TAA, TAG, orTGA within the gene). One ofthe first stepsin analyzing a genome is to identify its genes, which, as you certainly now realize,isa string-processing problem thatJava's Stri ng data type equips usto solve. Gen-eFind (Program 3.1.8) isa Java program that cando the job. To understand howitworks, we will consider a tiny example thatdoes not represent a real genome. Takea moment to identifythe genes markedby the start codon ATG and the end codonTAG in the following string:

ATAGATGCATAGCGCATAGCTAGATGTGCTAGC

There are several occurrences of both ATG and TAG, and they overlap in variousways, soyouhave to do a bit ofwork to identify thegenes. GeneFi nd accomplishesthe task in one left-to-rightscanthrough the genome, asshownnext.


Program 3.1.8 Findinggenes in a genome

18

It

public class GeneFind{

public static void main(String[] args) start

{ // Use start and stop to find genes in genome. stopString start = args[0];String stop = args[l];String genome = Stdin.readAll();int beg = -1;for (int i =0; i < genome.length(){ // Check next codon for start or

String codon = genome.substring(i, i+3);if (codon.equals(start)) beg = i;if ((codon.equals(stop)) && beg != -1){ // Check putative gene alignment.

String gene = genome.substring(beg+3,if (gene.length() % 3 == 0){ // Print and restart.

StdOut.pri ntln(gene);beg = -1;

}

genome

2; i++)stop.

i);

beg

codon

gene

start codon

stop codon

full genome

putativegenestartposition

character index

next codon

discovered gene

This program prints all the genes in the genome on standard input defined by the start and stopcodes on the command line. To find agene inagenome, we scan for the start codon, rememberits index, and then scan to the next stop codon. If the length of the intervening sequence is amultiple of3, wehavefounda gene.

% more genomeTiny.txtATAGATGCATAGCGCATAGCTAGATGTGCTAGC

% Java GeneFind ATG TAG < genomeTiny.txtCATAGCGCA

TGC

% java GeneFind ATG TAG < genomeVirus.txtCGCCTGCGTCTGTAC

TCGAGCGGATCGCTCACAACCAGTCGG

AGATTATCAAAAAGGATCTTCACC

3.1 Data Types 343

codon1

start stopuey

0 -1

1 TAG -1

4 ATG 4

9 TAG 4

16 TAG 4

20 TAG -1

23 ATG 23

29 TAG 23

gene remainingportion of inputstring





CATAGCGCA ATAGATGCATAGCGCATAGCTAGATGTGCTAGC



TGC ATAGATGCATAGCGCATAGCTAGATGTGCTAGC

Thevariable begholdsthe indexof the mostrecently encountered ATG start codon:thevalue -1 indicates that thecurrent portion ofthegenome could not be a gene,eitherbecause no ATG hasbeenseen (at thebeginning) or because no ATG hasbeenseensince the last genewas found. If weencounter a TAG stop codon when beg is-1, we ignore it; otherwise,we havefound a gene. This trace illustratesthe cases ofinterest: we ignore theTAG codons at 1and 20 because beg is -1, indicating that wehave not seen an ATG; we set beg to the current index each time that we encounteran ATG; we ignore the TAG at 9 because it marks the putative gene CA whose lengthisnot a multiple of3,soit could notbeasequence ofcodons; andwe outputgenesat 16and 29 because we have valid start andstop codons with no intervening stopcodons and a genelengththat isa multiple of 3.

GeneFi nd issimple but subtle, typical of stringprocessing programs. In practice,the rules that definegenesare more complicated than those we havesketched:othercodons may be prohibited, there may bebounds on the length, some geneshave to be spliced from multiple pieces, and genes satisfying various othercriteriamay be of interest. GeneFi nd is intended to exemplify how a basic knowledge ofJava programming can enable a scientist to make appropriate tools to studythesesequences. Actual genomes are similar to our test case, just much longer. You canexperiment with GeneFi nd to look for genes in genomeVi rus. txt and severalother genomes on the booksite. The quick leap from examining a toyprogrammingexample that illustrates thebasic Java Stri ng datatype to studying scientific questions on actual data is a remarkable characteristic of modern genomics. As wewillsee, someof the verysame algorithms that were developed by computerscientiststhat underly basic computational mechanisms andhave proven important in commercial applications are also nowplaying a critical role in genomic research.


Input and output revisited In Section 1.5 youlearnedhowto readand writenumbers and text using Stdin and StdOut and to make drawings with StdDraw.You have certainly come to appreciate the utility of these mechanism in gettinginformation into and out ofyour programs. One reasonthat theyare convenient isthat the "standard" conventions make them accessible from anywhere within a program. Onedisadvantage of these conventions isthat theyleave usdependent uponthe operating system's piping and redirection mechanism for access to files, andthey restrict us to working withjust one input file, one output input streamsfile, and one drawing for any given program. With object-oriented programming, we can definemechanisms that are similar to

Stdin, StdOut, and StdDraw butallow us to work with multipleinput streams, output streams,and drawings within one program.

Specifically, we define inthis section the data types In,Out, and Draw for input streams,output streams, and drawings(respectively). As usual, you candownload the files In. j ava, Out.java, and Draw.Java from thebooksite to use these data types.

These data types give us theflexibility that weneed to addressmany common data-processingtasks within our Java programs. Rather than being restricted to just one inputstream, one output stream, and onedrawing, we caneasily define multiple objectsof each type, connecting the streams to various sources and destinations. We alsoget the flexibility to assign such objects to variables, pass them as arguments orreturn values from methods, and to createarrays of them, manipulating them justaswemanipulate objects of anytype. We will consider several examples of their useafter we have presented the APIs.

to -

f —1

standard input -|jfUWH

pictures

drawings

command-liney arguments

output streams

A bird's-eye view ofa Java program (revisited again)

3.1 Data Types 345

Input stream data type. The data type In isa more general version of Stdin thatsupports reading numbers and text from files and websites as well as the standardinput stream. It implements the input stream data type, with the following API:

public class In

In () create an input stream from standard input

In (St ri ng name) create an input stream from afile or website

bool ean i sEmpty () true ifno more input, f al se otherwise

i nt readlnt () read a value oftype i nt

doubl e readDoubl e () read a value oftype doubl e

Note: All operations supported by Stdin are also supportedfor In objects.

APIforour data type for input streams

Instead ofbeing restricted to one abstract input stream (standard input), you nowalso have theability todirectly specify thesource ofaninputstream. Moreover, thatsource can beeither afile or a website. When invoked with a constructor having aStri ng argument, In will first trytofind a file in thecurrent directory ofyour localcomputer thathas thatname. If it cannot do so, it will assume theargument tobea website nameand will try to connect to that website. (Ifno suchwebsite exists, itwill issue a runtime exception.) Ineither case, thespecified file orwebsite becomesthesource of the input for the input stream object thus created, and the read*()methods will provide values from that stream. This arrangement makes it possibletoprocess multiple files within the same program. Moreover, the ability todirectlyaccess the web opens up the whole web as potential input for your programs. Forexample, it allows you toprocess data that is provided and maintained by someoneelse. You can find such files all over the web. Scientists now regularly post data fileswith measurements or results ofexperiments, ranging from genome and proteinsequences to satellitephotographs to astronomicalobservations; financial servicescompanies, suchasstockexchanges, regularly publish on theweb detailed information about the performance ofstock and other financial instruments; governmentspublish election results; and so forth. Now you can write Java programs that readthese kinds offiles directly. In gives you agreat deal offlexibility to take advantageof the multitude of data sources that are now available.


Output stream data type. Similarly, our data type Out is a more general versionof StdOut that supports writing text to a varietyof output streams,includingstandard output and files. Again, the API specifies the same methods as its StdOutcounterpart.You specify the file that you want to use for output by usingthe one-argument constructor withthe file's nameasargument. Outinterprets thisstringasthe nameof a newfile on yourlocal computer, and sendsitsoutput there.Ifyouusethe no-argumentconstructor, then you obtain standard output.

public class Out

Out () create an output stream tostandard output

Out (Stri ng name) create anoutput stream to afile

VOi d pri nt (Stri ng S) print s to the output stream

voi d pri ntl n(Stri ng s) print s and a newline to the output stream

VOid pri ntl n () print a newline tothe output stream

VOid pri ntf(Stri ng f, . . .) formatted print to the output steam

APIfor ourdata type foroutput streams

File concatenation and filtering. Program 3.1.9 is a sample client of In andOutthatuses multiple input streams toconcatenate several input files into asingle outputfile. Some operating systems have a command known as cat that implementsthis function. However, a Java program that does the same thing is perhaps moreuseful, because we can tailor it to filter the input files in various ways: we mightwish toignore irrelevant information, change theformat, orselect only some ofthedata, to name justa few examples. We now consider oneexample of such processing, andyoucanfindseveral others in the exercises.

Screen scraping. The combination ofIn (which allows ustocreate aninputstreamfrom any page ontheweb) and Stri ng (which provides powerful tools for processing text strings) opens up the entire web to direct access by our Java programs,withoutanydirect dependence on the operating system or the browser. Oneparadigm is known as screen scraping: the goal is to extract some information from aweb page with a program rather than having to browse to find it.To do so, we take

3.1 Data Types 347

• ^H&?£& ••\ •^-•':.:.'v v;

Program3.1.9 Concatenatingfiles

public class Cat{

public static void main(String[] args){ // Copy input files to out (last argument).

Out out = new Out(args[args.length-1]);for (int i = 0; i < args.length - 1; i++){ // Copy input file named on ith arg to out.

In in = new In(args[i]);String s = in.readAl1();out.println(s);

}}

}

This program creates an outputfile whose name is given by the last argument and whose contents are copies ofthe inputfiles whose names are given as the other arguments.

..• ••"*"{ 'l£^-'s«**-"'-?!'•''•''["* t&: '••'• =^*?:;>'''' ":''- ••'•'.'i3% more ini.txtThis is

% more in2.txt

a tinytest.

^m #?isf§PK8Klifl^Pi

% Java Cat ini.txt in2.txt out.txt

% more out.txt

This is

a tinytest.

'^^^^^^^ci^^^^^^SI^^P^^^^^^^^^iPP^^^^^

I

advantage of the fact that many web pages are defined with text files in a highlystructured format (because they are created bycomputer programs!). Your browserhas amechanism thatallows you toexamine the source code thatproduces thewebpage thatyou are viewing, and byexamining that source you can often figure outwhat to do. For example, suppose that we want totake a stock trading symbol as acommand-line argument and print out itscurrenttrading price. Such informationispublished ontheweb byfinancial service companies and internet service providers. For example, you canfind thestock price ofa company whose symbol is googbybrowsing to http: //fi nance. yahoo. com/q?s=goog. Like many web pages, thename encodes an argument (goog), andwe could substitute any otherticker sym-


<tr>

bol to get a web pagewith financial information for any other company. Also, likemanyother files on the web, the referenced file is a text file, written in a formattinglanguage known as HTML. (See the Context section at the end of this book forsome details about this language.) From the point of view of a Java program, it isjusta Stri ng value accessible throughan In input stream. You canuseyourbrowser to download the source of that file, or you could use

Java Cat "http://finance.yahoo.com/q?s=goog" mycopy.txt

to put the source into a local file mycopy.txt on your computer (thoughthere isno real need to do so). Now, suppose that goog is trading at $475.11 at the mo

ment.Ifyousearch for the string "475.11" in the sourceof that page, you willfind the stockprice buried within

<td class="yfnc_„tableheadl" some HTML code. Without having to know details ofwi dth="48%"> HTML, you can figure outsomething about the context</td>TPade = in w^ich the price appears. In this case, you can see that<td class="yfnc_tabledatalH> the stock price is enclosed between the tags "<b>" and<bigxb>475. ll</bx/big> "</b>", a bit after the string "Last Trade:". With the<tr>></tr> Stn" n9 data tyPe methods indexOf() and substri ng()<td class="yfnc„_tableheadl" y0U can easily grab this information, as illustrated inwidth=n48%"> StockQuote (Program 3.1.10). This program dependsTrade Time: , i r r\ ,,_<-. u</td> on the web page format of http://finance.yahoo.<td class=,,yfnc_tabledatal"> com; if this format changes, StockQuote not work. Still,11:13AM ET making appropriate changes is not likely to be difficult.

You can entertain yourselfby embellishingStockQuoteHTML codefrom the web inall ]dnds ofinteresting ways. For example, you could

grab the stock price on a periodic basis and plot it, compute a moving average, or save the results toa file for later analysis. Ofcourse, thesame technique works for sources ofdata found all over theweb. You can find manyexamples in theexercises at the end ofthis section andonthebooksite.

Extracting data. The ability to maintain multiple inputandoutputstreams givesusa great deal of flexibility in meeting thechallenges ofprocessing large amountsofdatacoming from avariety ofsources. We consider onemore example: Supposethat a scientist or a financial analyst hasalarge amountof datawithina spreadsheetprogram. Typically such spreadsheets are tables with a relatively large number ofrows anda relatively small number of columns. You are not likely to be interested

3. / Data Types 349

1

i

m

£i

Program3.1.10 Screenscrapingfor stockquotes

public class StockQuote{

public static double price(String symbol){ // Return current stock price for symbol.

In page = new In("http.-//finance, yahoo. com/q?s=" + symbol);String in = page.readAl1();int trade = in.indexOf("Last Trade:",int from = in.indexOf("<b>", trade);int to = in.indexOf("</b>", from);String price = in.substring(from + 3,return Double.parseDouble(price);

}

}

public static void main(String[] args){ StdOut.pri ntln(pri ce(args[0])); }

0);

to);

page

in

trade

from

to

price

input stream

contents o/page

Last. . . index

<b> index

</b> index

currentprice

This program takes the ticker symbol ofastock asa command-line argument, reads a web pagecontaining the stock price, finds the stock price using the Stri ng method i ndexOf(), extracts itusing the method substri ng(), and prints the price out to standard output.

% Java StockQuote goog475.11

% Java StockQuote adbe41.125

It

^^^^^W^^^^^^K^^^^^^^v^'

in all the data in the spreadsheet, but you maybe interestedin a fewof the columns.You can do some calculations within the spreadsheet program (this is its purpose,afterall), but you certainly do not have the flexibility that you have with Java programming. One wayto address this situation is to havethe spreadsheetexport thedata to a text file, using some special character to delimit the columns, and thenwrite a Java program that reads that file from an input stream. One standard practice is to use commasas delimiters: print one line per column,with commasseparating row entries. Such files are known as comma-separated-value or . csv files.With the spl i t () method in Java's Stri ng data type,we can read the file line-by-


iS(M^^^

Program 3.1.11 Splitting a file

mm

public class Split{

public static void main(String[] args){ // Split file by column into N files.

String name = args[0];int N = Integer.parselnt(args[l]);String delim = ",";

// Create output streams.Out[] out = new Out[N];for (int i = 0; i < N; i++)

out[i] = new Out(name + i + ".txt");

name basefile name

N argument index

delim delimiter (comma)

i n inputstream

out[] output streams

line current line

f i el ds [] values in current line

In in = new In(name + ".csv");while (!in.isEmptyO){ // Read a line and write fields to output streams.

String line = in.readLineO;String[] fields = 1ine. split (del i m);for (int i = 0; i < N; i++)

out[i].pri ntln(fi elds[i]);}

}

This program uses multiple output streams to split a .csv file into separate files, one for eachcomma-delimitedfield. The name ofthe outputfilecorresponding to the i th field isformed byconcatenating i and then . txt to the end of the originalfile name.

% more DJIA.csv

31-Oct-29,264.97,7150000,273.5130-Oct-29,230.98,10730000,258.4729-0ct-29,252.38,16410000,230.0728-0ct-29,295.18,9210000,260.6425-Oct-29,299.47,5920000,301.2224-0ct-29,305.85,12900000,299.4723-Oct-29,326.51,6370000,305.8522-0ct-29,322.03,4130000,326.5121-Oct-29,323.87,6090000,320.91

£% Java Split DJIA 3

% more DJIA2.txt

7150000

10730000

16410000

9210000

5920000

12900000

6370000

4130000

6090000

^^^Si^^^^^^^SS^^^^Sg^SS^^

isragswssw

3.1 Data Types 351

line and isolate the data that we want. Wewill see severalexamples of this approachlater in the book. Spl i t (Program 3.1.11) is an In and Out client that goes one stepfurther: it creates multiple output streams and makes one file for each column.

Theseexamples are convincing illustrations of the utility of working with text files,with multiple input and output streams, and with direct access to web pages.Webpagesare written in HTML preciselyso that they are accessible to any program thatcan read strings. People use text formats such as . csv filesrather than data formatsthat are beholden to particular applications precisely in order to allow as manypeople as possibleto access the data with simpleprograms likeSpl i t.

Drawing data type. Whenusing the Pictu re datatypethat weconsidered earlierin this section, we could write programs that manipulated multiple pictures, arraysof pictures, and so forth, precisely because the data type provides us with thecapability for computing with Picture objects. Naturally, wewould like the samecapability for computing with the kinds of objects that we create with StdDraw.Accordingly, wehavea Draw data typewith the following API:

public class Draw

Draw()



Note: All operations supported by StdDraw are also supportedforDraw objects.

As for anydata type, you can create a newdrawing by using new to create a Drawobject, assign it to a variable, and use that variable name to call the methods thatcreate the graphics.For example,the code

Draw d = new Draw();d.circle(.5, .5, .2);

draws a circle in the center of a window on your screen. As with Picture, eachdrawing hasitsownwindow, so that youcanaddress applications that call for multiple different drawings.


Properties of reference types Now that you have seen several examples ofreference types (Charge, Color, Picture, String, In, Out, and Draw) and clientprograms that use them, we discuss in more detail some of their essential properties. To a large extent, Java protects novice programmers from having to knowthese details. Experienced programmers know that a firm understanding of theseproperties is helpful in writing correct, effective, and efficientobject-oriented programs.

A reference captures the distinction between a thing and its name. This distinction is a familiar one, as illustrated in these examples:

type typical object typical name

website our booksite www.cs.pri nceton.edu/IntroProgrammi ng

person father of computer science Alan Turing

planet third rock from the sun Earth

building our office 35 Olden Street

ship superliner that sank in 1912 RMS Titanic

number circumference/diameter in a circle IT

Picture new Picture("mandrill.jpg") pic

A given object may have multiple names, but each object has its ownidentity. Wecan createa newname for an objectwithout changing the object's value (viaan assignment statement), but when we change an object's value (by invoking an instance method), all of the object'snames refer to the changed object.

Thefollowing analogy mayhelpyoukeep thiscrucial distinction clearin yourmind. Suppose that you want to have your house painted, so you write the streetaddress ofyourhouse in pencil on a piece of paperand give it to a few housepainters. Now, if youhireoneof the painters to paint the house, it becomes a differentcolor. Nochanges have beenmade to anyof the pieces of paper, but the house thattheyall refer to has changed. Oneof the painters mighterase whatyou've writtenand write the address of another house, but changing what is written on one pieceofpaper does not change what iswritten on another piece ofpaper. Java referencesare like the pieces of paper: theyhold names of objects. Changing a reference doesnot changethe object,but changingan objectmakesthe changeapparent to everyone having a reference to it.

3.7 Data Types

The famous Belgian artist Rene Magritte captured this same concept in apainting where he created an image of a pipe along with the caption ceci nyest pasunepipe {this is notapipe) below it. We might interpret the caption as sayingthat the image is not actuallya pipe, just an imageof a pipe. Or perhaps Magritte meant that the caption is neithera pipe nor an image of a pipe, just a caption! In the present context, this image reinforces the idea that a reference to an objectis nothing more than a reference; it is not the object itself.

353

C&u. n-eAtpa* wwfuft&.

Aliasing. An assignment statement with a reference type creates a second copy of the reference. The assignment statementdoes notcreate a new object, just another reference to an existingobject. Thissituation is known as aliasing: both variables refer to the sameobject.The effect of aliasing is a bit unexpected,because it is different than for variables

holding values of a primitive type. Be sure thatyou understand the difference. If x and y are variables of a primitive type, then the assignmentstatement x = y copies thevalue of y to x. For reference types,the reference is copied(not the value). Aliasing is a common source of bugs inJava programs, as illustratedby the following example:

This is a picture of a pipe

Color a =

new Col or(160, 82, 45);Color b = a;

811

812

813

811

811

160

82

45

preferences* Picture a = new PictureC'mandrill.jpg");same object Picture b = a;

a.set(i, j, colorl); // a is updatedb.set(i, j, color2); // a is updated again

After the assignment statement, the variables a and b bothrefer to the same Picture. Changing the state of an object impacts all code involving aliasedvariables referencing that object. We are used to thinking of two differentvariables of primitivetypesasbeing independent, but that

-sienna intuition does not carry overto reference objects. For example, if the code above is assuming that a and b refer todifferent Picture objects, then it willproduce the wrongresult. Such aliasing bugs dace, common in programs written by peoplewithout much experience in usingreference

Aliasing objects (that'syou, sopayattentionhere!).


Immutable types. For this veryreason, it is common to define data types whosevalues cannot change.A data type that has no methods that can change an object'svalue is said to be immutable (as are objects of that type). For example, Java's Colorand Stri ng objects are immutable (there are no operations available to clients thatchange a color's value), but Picture objects are mutable (we can change pixel colors). We will consider immutability in detail in Section 3.3.

Comparing objects. When applied to references, the == operator checks whetherthe two references have the same identity (that is, whether they point to the sameobject). That is not the same as checkingwhether the objects have the same value.For example, consider the following code:

Color a = new Color(142, 213, 87);Color b = new Color(142, 213, 87)',Color c = b;

Now (a == b) is fal se and (b == c) is true, but when you are thinking aboutequality testingfor Col or, you probably are thinking that you want to test whether their values are the same—you might want all three of these to test as equal.Java does not have an automatic mechanism for testing equality of object values,which leaves programmers with the opportunity (and responsibility) to define itfor themselves by definingfor any class a customizedmethod named equal s (), asdescribedin Section 3.3.For example, Col or has such a method, and a. equal s (c)is true in our example. Stri ng also contains an implementationof equal s () becausewe often want to test that two Stri ng objects have the same value.

Pass by value. When we call a method with arguments, the effect in Java is as ifeachargumentvaluewere to appearon the right-hand sideof an assignment statement with the corresponding argument name on the left.That is, Java passesa copyof the argumentvaluefrom the calling program to the method. This arrangementis known aspass by value. One important consequence is that the method cannotchange the value of a caller's variable. For primitive types, this policy is what weexpect (the two variables are independent), but each time that we use a referencetype as a method argument, we create an alias, so we must be cautious. In otherwords, the convention is to pass the reference by value (make a copy of it) but topassthe object byreference. Forexample, if wepassa reference to an objectof typePicture, the method cannot changethe original reference (make it point to a dif-

3.1 Data Types 355

ferent Picture), but it can changethe valueof the object,for exampleby invokingthe method set() to change a pixel'scolor.

Arrays are objects. In Java, every value of anynonprimitive type is an object. Inparticular, arrays are objects.Aswith strings, there is speciallanguage support forcertain operations on arrays: declarations, initialization, and indexing. As with anyother object,when we pass an array to a method or use an array variable on the right hand side of an assignment statement, we are making a copy of the array reference, not a copy of the array. Arrays aremutable objects: This convention is appropriate for the typical casewhere we expect the method to be able to modify the array by rearranging its entries, as in, for example, the exch() and shuffleOmethods that we considered in Section 2.1.

Arrays ofobjects. Array entries canbeofanytype, aswehave alreadyseen on several occasions, from args [] (an array of strings) in ourmai n() implementations, to the array of Charge objects in Program3.1.7.When we create an array of objects,we do so in two steps:

• Create the array, using the bracket syntax for array constructors• Create each object in the array,using a standard constructor

For example,we would use the following code to create an array oftwo Charge objects:

Charged a = new Charge[2];

a[0] = new Charge(.51, .63, 21.3);

a[l] = new Charge(.13, .94, 85.9);

Naturally,an array of objects in Javais an array of references^ not theobjects themselves. If the objects are large, then we gain efficiencyby not having to move them around, just their references. If they aresmall,we lose efficiency by having to follow a reference each time weneed to get to some information.

\.

a

123 •• 323

124 2

a.length

323 459 -«-a[0]

324 611 — a[l]

459 .51

460 .63

461 21.3

611 .13

612 .94

613 81.9

An arrayof objects

Safe pointers. To provide the capability to manipulate memoryaddresses that refer to data, many programming languagesinclude the pointer (which is like the Javareference) as a primitive data type. Programming with pointers is notoriously error


prone, so operations provided for pointers need to be carefully designed to helpprogrammers avoid errors. Java takes this point of view to an extreme (that is favored by many modern programming-language designers). In Java, there is onlyoneway to create a reference (new) and only oneway to change a reference (with anassignment statement). That is, the only things that a programmer can do withreferences is to create them and copy them. In programming-language jargon, Java references are known as safepointers, because Java can guarantee that each referencepoints to an object of the specified type. Programmersused to writing code that directly manipulates pointersthink of Java as having no pointers at all, but people stilldebate whether it is really desirable to have unsafe pointers. In short, when you program in Java, you will not bedirectly accessing pointer values, but if you find yourselfdoing so in some other language in the future, be careful!

Orphaned objects. The ability to assign a new value toa reference variable creates the possibility that a programmay have created an object that it can no longer reference.For example, consider the three assignment statements inthe figure at right. After the third assignment statement,not only do a and b refer to the same Color object (theone whose RGB values are 160,82, and 45), but also thereis no longer a reference to the Color object that was created and used to initialize b. The only reference to thatobject was in the variable b, and this reference was overwritten by the assignment, so there is no way to refer tothe object again. Such an object is said to be orphaned.Objects are also orphaned when they go out of scope. Javaprogrammers pay little attention to orphaned objects because the system automatically reuses the memory thatthey occupy, as we discuss next.

Color a =

new Col or(160, 82, 45);Color b =

new Color(255, 255, 0);Color b = a;

i

a 811 >*\ references tob 811

jS sameobject

orphaneds object

655 255

656 255 -<— yellow

657 0

811 160

812 82 •<— sienna

813 45

1 1

An orphaned object

Memory management. Programs tend to create huge numbers of objects (andprimitive-type variables) but only have a need for a small number of them at anygiven point in time. Accordingly, programming languages and systems need mech-

3.1 Data Types 357

anisms to allocate memory for data type values during the time they are neededand to free the memory when they are no longer needed (for an object, sometimeafter it is orphaned). Memory management is easier for primitive types because allof the information needed for memory allocation is known at compile time. Java(and most other systems) take care of reserving space for variables when they aredeclared and freeing that space when they go out of scope. Memory managementfor objects is more complicated: the compiler knows to allocate memory for anobject when it is created, but cannot know precisely when to free the memory associated with an object, because the dynamics of a program in execution determinewhen an object is orphaned.

Memory leaks. In many languages (such as C and C++) the programmeris responsible for both allocating and freeing memory. Doing so is tedious andnotoriously error-prone. For example, suppose that a program deallocates thememory for an object, but then continues to refer to it (perhaps much later in theprogram). In the meantime, the system may have allocated the same memory foranother use, so all kinds of havoc can result. Another insidious problem occurswhen a programmer neglects to ensure that the memory for an orphaned object isdeallocated. This bug is known as a memory leak because it can result in a steadilyincreasing amount of memory devoted to orphaned objects (and therefore notavailable for use). The effectis that performance degrades, just as if memory wereleakingout of your computer. Haveyou everhad to reboot your computer becauseit was gradually getting less and less responsive? A common cause of such behavioris a memory leak in one of your applications.

Garbage collection. One of Java's most significant features is its ability to automaticallymanage memory. The idea is to free the programmers from the responsibilityof managing memory by keeping track of orphaned objectsand returningthe memory they use to a pool of free memory. Reclaiming memory in this way isknown as garbage collection, and Java's safe pointer policy enables it to do this efficiently and automatically. Garbagecollection isan old idea,but people still debatewhether the overhead of automatic garbage collection justifies the convenience ofnot having to worry about memory management. The same conclusion that wedrew for pointers holds: when you program in Java, you will not be writing code toallocate and free memory, but if you find yourself doing so in some other languagein the future, be careful!


For reference, we summarize the examples that we have considered in this section in

the table below. These examples are chosen to help you understand the essentialproperties of data types and object-oriented programming.

A data type isa setofvalues andasetofoperations defined onthose values. Withprimitive data types,we workedwith a smalland simple set of values. Colors,pictures, strings, and input-output streams are high-level data types that indicate thebreadth of applicabilityof data abstraction. You donotneed toknow howa datatypeis implemented in order tobeable touse it. Eachdata type (there are hundreds in the

Javalibraries, and you will soon learn tocreate your own) is characterized by anAPI (application programming interface) that provides the information thatyou need in order to use it. A client program creates objects that hold data typevalues and invokes instance methods to

manipulate those values. We write client programs with the basic statementsand control constructs that you learnedin Chapters 1 and 2, but now have thecapability to work with a vast variety ofdata types, not just the primitive ones to

which you have grown accustomed. With experience,you will find that this abilityopens up for you new horizons in programming.

Our Charge example indicates that you can tailor one or more data typesto the needs of your application. The ability to do so is profound, and also is thesubject of the next section. When properly designed and implemented, data typeslead to client programs that are clearer, easier to develop, and easier to maintainthan equivalent programs that do not take advantage of data abstraction. The clientprograms in this section are testimony to this claim. Moreover, as you will see inthe next section, implementing a data type is a straightforward application of thebasic programming skills that you have already learned. In particular, addressing alarge and complex application becomes a process of understanding its data and theoperations to be performed on it, then writing programs that directly reflect thisunderstanding. Once you have learned to do so, you might wonder how programmers ever developed large programs without using data abstraction.

API description

Charge electrical charges

Color colors

Picture digital images

String characterstrings

In input streams

Out output streams

Draw drawings

Summary ofdatatypes in this section

3.1 Data Types

Q. Why the distinction between primitive and referencetypes?

A. Performance. Javaprovides the wrapper reference types Integer, Double, andso forth that correspond to primitive types and can be used by programmers whoprefer to ignore the distinction. Primitive types are closer to the types of data thatare supported by computer hardware, so programs that use them usually run fasterthan programs that use corresponding referencetypes.

Q. What happensif I forget to use new whencreating an object?

A. ToJava, it looks as though you want to call a staticmethod with a return valueof the objecttype. Since you have not defined sucha method, the error message isthe sameaswhen you refer to an undefinedsymbol. If you compile the code

Charge c = Charge(.51, .63, 21.3);

you get this error message:

cannot find symbolsymbol : method Charge(double,double,double)

Constructors do not provide return values (their signature has no return valuetype)—they can only follow new. You get the same kind of error message if youprovide the wrong number of arguments to a constructor or method.

Q. Why don'twewrite StdOut. printl n(x. toStri ng()) to printobjects thatarenot strings?

A. Good question. That code works fine, but Java saves us the trouble of writingit byautomatically invoking toStri ng() for us anytime a Stri ng type is needed.This policyimplies that everydata type must havea toStri ng() method. Wewilldiscuss in Section 3.3. Java's mechanism for ensuring that this is the case.

Q. What is the differencebetween =,==, and equal s ()?

A, The single equals sign (=) is the basis of the assignment statement—you certainly are familiar with that. The double equals sign (==) is a binaryoperator forchecking whether its twooperands areidentical. If the operands areof a primitive


type, the result is true if they havethe samevalue,and f al se otherwise. If the operands are references, the result is true if they refer to the same object, and f al seotherwise.That is,we use == to test object identity equality. The data-type methodequal s () is included in everyJavatype so that the implementation can provide thecapability for clients to test whether two objects have the same value. Note that (a== b) implies a. equal s (b), but not the other way around.

Q. How can I arrange to passan array to a function in such a waythat the functioncannot change the array?

A, There is no direct wayto do so—arrays are mutable. In Section 3.3,you will seehow to achieve the same effect by building a wrapper data type and passing a valueof that type instead (Vector, in Program 3.3.3).

Q. What happens if I forget to use new when creating an array of objects?

A. Youneed to use new for each object that you create, so when you create an arrayof N objects, you need to use new N+l times: once for the array and once for eachof the N objects.If you forget to createthe array:

Charged a;

a[0] = new Charge(0.51, 0.63, 21.3);

yougetthe sameerror message that youwouldgetwhentryingto assign a value toany uninitialized variable:

variable a might not have been initializeda[0] = new Charge(0.51, 0.63, 21.3);

but if you forget to use new when creating an objectwithin the array and then tryto use it to invoke a method:

Charged a = new Charge[2];

double x = a[0].potentialAt(.5, .5);

you geta Nul 1PointerExcepti on.As usual, the bestwayto answer such questionsis to write and compile such code yourself, then try to interpret Java's error message. Doing so might help you more quicklyrecognize mistakeslater.

3.1 Data Types

Q. Where can I find more details on how Java implements references and garbagecollection?

A. One Javasystem might differ completelyfrom another. For example, one natural scheme is to use a pointer (machine address); another is to use a handle (apointer to a pointer). The former givesfaster access to data; the latter provides forbetter garbage collection.

Q. Why red, green, and blue instead of red,yellow, and blue?

A. In theory, any three colors that contain some amount of each primary wouldwork, but two different schemes have evolved: one (RGB) that has proven to produce good colors on television screens, computer monitors, and digital cameras,and the other (CMYK) that is typically used for the printed page (see Exercise1.2.21). CMYK does include yellow (cyan, magenta, yellow, and black). Two different schemes are appropriate because printed inks absorb color, so where thereare two different inks there are more colors absorbed and fewer reflected;but videodisplays emit color, so where there are two different colored pixels there are morecolors emitted.

Q. What exactly does it mean to i mport a name?

A. Not much: it just saves some typing. You could type Java.awt.Color everywhere in your code instead of using the i mport statement.

<)• Is there anything wrongwith allocating and deallocating thousands of Colorobjects, as in Grayscal e (Program 3.1.4)?

A. Allprogramming-language constructs come at some cost. In this case the costis reasonable, since the time for these allocations is tiny compared to the time toactually draw the picture.

Q. Whydoesthe Stri ng method call s. substri ng(i, j) return the substringofs starting at index i and ending at j -1 (and not j)?

A. Whydo the indicesof an array a [] go from 0 to a. 1ength-1 instead of from 1to 1ength? Programming-language designers make choices; we live with them.


3.1.1 Write a program that takes a doubl e value wfrom the command line, creates four Charge objects with charge value 1.0 that are each distance win each ofthe four cardinal directions from (.5, .5), and prints the potential at (.25, .5).

3.1.2 Write a program that takes from the command line three integers between0 and 255 that represent red, green, and blue values of a color and then creates andshows a 256-by-256 Picture of that color.

3.1.3 ModifyAl bersSquares (Program3.1.2) to take nine command-line arguments that specifythree colorsand then drawsthe sixsquaresshowingall the Alberssquares with the largesquare in eachcolor and the small square in each differentcolor.

3.1.4 Write a program that takes the name of a grayscale picture file as acommand-lineargumentand uses StdDraw to plot a histogramof the frequency ofoccurrence of each of the 256 grayscaleintensities.

3.1.5 Write a program that takes the name of a picture file as a command-lineargument and flips the image horizontally.

3.1.6 Write a programthat takes the nameof an picturefile as a command-lineinput,and creates threeimages, onethat contains onlythe redcomponents, one forgreen, and one for blue.

3.1.7 Write a programthat takes the nameof an picturefile as a command-lineargumentand prints the pixel coordinates of the lower left corner and the upperright cornerof the smallest bounding box (rectangle parallel to the x- and y-axes)that contains all of the non-white pixels.

3.1.8 Write a program that takes as command line arguments the name of animage file and the pixel coordinates of a rectangle within the image; reads fromstandard input a list of Color values (represented as triples of int values); andserves asa filter, printing out thosecolorvalues for whichallpixels in the rectangleare background/foreground compatible. (Such a filter can be used to pick a colorfor text to label an image.)

3.1 Data Types

3.1.9 Write a function isValidDNAO that takes a string as input and returnst rue if and only if it is comprised entirely of the characters A, C, T,and G.

3.1.10 Write a function compl ementWC () that takesa DNAstring as its inputs andreturns its Watson-Crick complement: replaceAwith T,Cwith G, and vice versa.

3.1.11 Write a function pal i ndromeWC () that takes a DNA string as its input andreturns true if the string is a Watson-Crick complemented palindrome, and f al seotherwise. A Watson-Crick complemented palindrome is a DNA string that is equalto the reverse of its Watson-Crick complement.

3.1.12 Write a program to check whether an ISBN number is valid (see Exercise1.3.33), taking into account that an ISBN number can have hyphens inserted atarbitrary places.

3.1.13 What does the followingcode fragment print?

String stringl = "hello";String string2 = stringl;stringl = "world";StdOut.pri ntln(stri ngl);StdOut.pri ntln(stri ng2);

3.1.14 What does the following code fragmentprint?

String s = "Hello World";s.tollpperCaseO;s.substring(6, 11);StdOut.println(s);

Answer. "Hello World". String objects are immutable—string methods eachreturn a new String object with the appropriate value (but they do not changethe value of the object that was used to invoke them). This code ignores theobjects returned and just prints the original string. To print "WORLD", use s =s.tollpperCaseO ands = s.substring(6, 11).

363


3.1.15 A string s is a circular shiftof a string t if it matches when the charactersare circularly shifted by any number of positions. For example, ACTGACG is a circularshift of TGACGAC, and vice versa.Detecting this condition is important in the studyof genomic sequences. Write a program that checks whether two given strings sand t are circular shifts of one another. Hint: The solution is a one-liner with i n-

dexOf() and string concatenation.

3.1.16 Given a string site that represents a website, write a code fragment todetermine its domain type. For example, the domain type for the string http: //www.cs.princeton.edu/IntroProgramming is edu.

3.1.17 Write a static method that takes a domain name as argument and returnsthe reversedomain (reversethe order of the strings between periods). For example,the reverse domain of cs. pri nceton. edu is edu. pri nceton. cs. This computation is useful for web log analysis. (See Exercise 4.2.35.)

3.1.18 What does the following recursive function return?

public static String mystery(String s){

int N = s.lengthO;if (N <= 1) return s;String a = s.substring(0, N/2);String b = s.substring(N/2, N);return mystery(b) + mystery(a);

}

3.1.19 Modify GeneFi ndto handleallthree stop codes(insteadof handling themone at a time through the commandline).Also add command-line arguments to allowthe user to specify lowerand upper bounds on the length of the genesought.

3.1.20 Write a version of GeneFind based on using the indexOf() method inStri ng to find patterns.

3.1.21 Write a program that takes a start string and a stop string as command-line arguments and prints all substrings of a given string that start with the first,end with the second, and otherwise contain neither. Note: Be especially careful ofoverlaps!

3.1 Data Types

3.1.22 Write a filter that reads text from an input stream and prints it to an outputstream, removing any lines that consist only of whitespace.

3.1.23 Modify Potential (Program 3.1.7) to take an integer N from the command line and generate AT random Charge objectsin the unit square, with potentialvalues drawn randomly from a Gaussian distribution with mean 50 and standarddeviation 10.

3.1.24 Modify StockQuote (Program 3.1.10) to take multiple symbols on thecommand line.

3.1.25 The examplefile data used for Spli t (Program3.1.11) lists the date, highprice,volume, and low price of the DowJones stockmarket average for everydaysince records have beenkept.Download this file fromthe booksite and writea program that createstwo Draw objects, one for the pricesand one for the volumes,andplots them at a rate taken from the command line.

3.1.26 WriteaprogramMe rge that takes adelimiter stringfollowed byan arbitrarynumber of file namesascommandlinearguments, concatenates the correspondinglines of each file, separated by the delimiter,and then writes the result to standardoutput, thus performing the opposite operation from Spl i t (Program 3.1.11).

3.1.27 Find a website that publishes the current temperature in your area, andwrite a screen-scraperprogram Weather so that typing Java Weather followed byyour zip code will giveyou a weather forecast.

3.1.28 Suppose that a[] and b[] are eachinteger arrays consisting of millions ofintegers. What does the following codedo, and howlong does it take?

int[] t = a; a = b; b = t;

Answer. It swaps them, but it does so by copying references, so that it is not necessary to copy millions of elements.

365


CmatMesM^^mms.

3.1.29 Picture filtering. Write a library RawPicture with read() and write()methods for use with standard input and standard output. The write() methodtakes a Picture as argument and writes the picture to standard output, using thefollowingformat: if the picture isw-by-/z, write w,then /z, then whtriples of integersrepresenting the pixelcolorvalues, in rowmajor order.The read () method takesno arguments and returns a Picture, which it creates by reading a picture fromstandard input, in the format just described. Note: Be aware that this will use upmuch more diskspacethan the picture—thestandard formats compress this information so that it will not take up so much space.

3.1.30 Sound visualization. Write a program that uses StdAudio and Picture tocreate an interesting two-dimensional colorvisualization of a sound file while it isplaying. Be creative!

3.1.31 Kama Sutra cipher. Writea filter KamaSutra that takestwo stringsas command-line argument (the key strings), then reads standard input, substitutes foreachletter as specified by the keystrings, and writesthe result to standard output.Thisoperationisthebasis foroneof the earliest knowncryptographic systems. Theconditionon the keystringsis that theymustbe of equallengthand that anyletterin standard input must be in one of them.Forexample, if input is allcapitallettersand the keys areTHEQUICKBROWN and FXJMPSVRLZYDG, then wemake the table.

U I C

P S V

K B R 0 W N

L A Z Y D G

which tells us that we should substitute F for T, T for F, Hfor X, Xfor H, and so forthwhen copying the input to the output. The message is encoded by replacing eachletter with its pair. For example, the message MEET AT ELEVEN is encoded as Q33FBF JKJCJG. Someonereceiving the message can use the same keys to get the messageback.

3.1.32 Safepassword verification. Writea staticmethod that takesa string asargument and returns true if it meets the followingconditions, f al se otherwise:

• At least eight characters long• Contains at least one digit (0-9)• Contains at least one upper-case letter

3.1 Data Types 367

• Contains at least one lower-case letter

• Contains at least one character that is neither a letter nor a number

Suchchecks are commonly used for passwords on the web.

3.1.33 Color study. Writea program that displays the colorstudyshown at right,which gives Albers squares corresponding to eachof the 256 levels of blue and gray that were used to DlIilZitMlIiaailMlilll'Blillilliprint thisbook. ^^^^^^^^^^^^^^^^^^M

3.1.34 Entropy. The Shannon entropy measures ^^^^^^^^B^^^^S^^^mthe information content ofan input string and plays nSHHHUa cornerstone role in information theory and data ]^Q^^^^^^ffm^^0^0li^^icompression. Given a string of Ncharacters, let fc ^^^S^^mBS^XM^^MMbe the frequency of occurrence ofcharacter cThe |i^fi^^^^^^^^^Sl^^^Squantity pc = fc/N is anestimate ofthe probability ',y''''^;gWWm§Wm^VmM:*withat c would be in the string if it were a random l a B a a p • m•••••• •string, and the entropy is defined to be the sum of '-' »•••••••••••••the quantity -pclog2pc, over all characters that ap- •^•••••••••••ipear in the string. The entropy is said to measure :~. &t mmmmmmmmmmmwthe information content of a string: if eachcharacterappears the same number times, the entropy is atits minimum value.Write a program that computesand prints the entropy of the string on standard input. Run your program on awebpagethat you read regularly, a recentpaper that you wrote,and on the fruit flygenome found on the website.

3.1.35 Minimizepotential. Write a function that takesan array of Charge objectswith positivepotential as its argument and finds a point such that the potential atthat point iswithin 1%of the minimum potentialanywhere in the unit square.Usea Charge object to return this information. Add a call to this function and printout the point coordinates and chargevaluefor the data givenin the text and for therandom charges described in Exercise 3.1.23.

3.1.36 Slide show. Write a program that takes the names of several image files ascommand-line arguments and displays them in a slide show (one every two seconds), using a fade effect to black and a fade from black between pictures


3.1.37 Tile. Writea program that takesthe name of an imagefile and two integersM and N as command-line arguments and creates an M-by-JV tiling of the picture.

3.1.38 Rotation filter. Write a program that takes two command-line arguments (the name of an imagefile and a realnumber theta)and rotates the image 0 degrees counterclockwise. To rotate, copythe color ofeach pixel (sf, s;) in the source image to a target pixel(t;, f •) whose coordinates are given by the following formulas:

t{ = (s{ —cf)cos0 ~ (s;- - c;)sin0 + c{

tj = (s; - cf)sin0 + (sj - c;)cos0 + c;-

where (cf, cj) is the center ofthe image.

3.1.39 Swirlfilter. Creating a swirleffectis similar to rotation, except that the angle changes as a function of distance to the center.Use the same formulas as in the previous exercise, but compute 0as a function of (sf, s;), specifically tt/256 times the distance to thecenter.

3.1.40 Wavefilter. Write a filter like those in the previous two exercisesthat creates a waveeffect, by copyingthe color of each pixel(sf, sj) in the source image toa target pixel (t{, t;), where t{ =s; andtj =Sj +20sin(2 tts^/128). Add code totake the amplitude (20 intheaccompanying figure) and the frequency (128 in the accompanying figure) as command-line arguments.Experiment with variousvalues of these parameters.

3.1.41 Glassfilter. Write a program that takes the name of an image file as a command-line argument and applies a glass filter, seteach pixel p to the color of a random neighboring pixel (whosepixel coordinates both differ fromp's coordinates by at most 5).

rotate 30 degrees

swirlfilter

wavefilter

glassfilter

Exercises infiltering

3. / Data Types

3.1.42 Morph. Theexample images in the textfor Fade do not quitelineup in thevertical direction (the mandrill's mouth is much lower than Darwin's). ModifyFade to add a transformation in the vertical dimension that makes a smoothertransition.

3.1.43 Digital zoom. Write a program Zoom that takes thename of an image file and three numbers s, x, and y as command-line arguments and shows an output image that zoomsin on a portion of the input image. The numbers are all between 0and 1,withsto be interpreted asascale factor and (x,y)as the relative coordinates of the point that is to be at the centerof the output image. Use this program to zoomin on yourdogor a friend in some digital image on your computer. (If yourimage camefroma cell phoneor anoldcamera, youmaynot beableto zoom in too close without having visible artifacts fromscaling.)

3.1.44 Edge detection. An edge is an area of a picture with astrong contrast or discontinuity in intensity from one pixel tothe next. Finding the edges of an image isa fundamental problem in image processing and computer vision because edgescharacterize the object boundaries.Write a program EdgeDe-tect that takes the name of an imagefile and produces an imagewith the edgeshighlighted.

java Picture kitten.jpg java EdgeDetect kitten.jpg

Edgedetection

java Zoom pup

Digital zoom

369


3.2 Creating Data Types

In principle, wecould write all of our programs using only the eight built-in primitive types, but, as we sawin the last section, it is much more convenient to writeprograms at a higherlevel of abstraction. Thus,a variety of data types arebuilt intothe Java language and libraries. Still, we certainly cannot expect Java to containevery conceivable data type that wemighteverwishto use, soweneedto be abletodefine our own. The purpose of this section is to explain how to build data typeswith the familiar Java cl ass. 3-2-1 Charged-particle implementation .375

Implementing adata type as aJava ?•" Stopwatch .379. r 5-13C / • i 3-2-3 Histogram 381

class is not very different from imple- 324 Turtle graphics 383menting a function library as a set of 3.2.5 Spira mirabilis . .387static methods. The primary difference 3.2.6 Complex numbers .393is that we associate data with the meth- 32J Mandelbrot set 397

, . , , ,. rp, Am .£ 3.2.8 Stockaccount . .401od implementations. The API specifiesthe methods that we need to implement, Programs in this sectionbut we are free to choose any convenientrepresentation. To cement the basic concepts, we begin by considering the implementation of the data type for chargedparticles that weintroduced at the beginning of Section3.1. Next, weillustrate theprocess of creating data typesby considering a range of examples, from complexnumbers to stock accounts, including a number of software tools that we will uselater in the book. Useful client code is testimony to the value of any data type, sowe also consider a number of clients, including one that depicts the famous andfascinatingMandelbrot set.

The process of defining a data type is known as data abstraction (asopposedto thefunction abstraction style that is the basisof Chapter 2).Wefocuson the dataand implement operations on that data. Wheneveryoucan clearly separate data andassociated operations within aprogram, youshould doso. Modeling physicalobjectsor familiar mathematical abstractions is straightforward and extremely useful, butthe true power of data abstraction is that it allows us to model anything that wecan precisely specify. Once you gain experience with this style of programming,you will see that it naturally helps us address programming challengesof arbitrarycomplexity.


Basic elements of a data type To illustrate theprocess ofimplementing a datatype in a Java class, we discuss in detail an implementation of the Charge datatype of Section 3.1.Wehave already considered clientprogramsthat demonstratethe utility of having such a data type (in Programs3.1.1 and 3.1.7)—nowwe focuson the implementation details. Every data-type implementation that you will develop has the samebasicingredients as this simple example.

API. The application programming interface is the contract with all clients and,therefore, the starting point for any implementation. To emphasize that APIs arecriticalfor implementations, we repeathere our example ChargeAPI:

public class Charge


double potential At (double x, double y) electric potential at(x, y) due to charge


APIfor charged particles {see Program 3.2.1)

To implement Charge, weneedto define the datatypevalues, implement the constructor that creates objects having specified values, and implementtwo methodsthat manipulate those values. When faced with the problem of creating a completely new class for some application, thefirst step isto develop anAPI. This stepisa design activity that wewill address in Section 3.3. We needto design APIs withcarebecause afterwe implement classes and writeclient programs that use them,wedo notchange the API, because that would imply changing allclients.

Class. Thedata-typeimplementation isa Java cl ass. As withthe libraries of staticmethods that we have beenusing, we put the code fora datatypein a file with thesamename asthe class, followed bythe . j ava extension. We have been implementing Java classes, but the classes that we have been implementing do not have thekeyfeatures of data types: instance variables, constructors, and instance methods. Instance variables aresimilarto the variables that wehave beenusingin our program,and constructors and methods are similar to functions, but their effect is quitedifferent. Eachof these buildingblocks is also qualified by an access (or visibility)modifier. Wenext consider these four concepts, with examples.


Access modifiers. Thekeywords publi c, pri vate, and f i nal that sometimes precede classand variable names are known as access modifiers. The publ \c and private modifiers control access from client code: we designate every instance variable and method within a class as either publ i c (this entity is accessible by clients)or private (this entity is not accessible by clients). The fi nal modifier indicatesthat the valueof the variablewillnot changeonce it is initialized—its access is readonly. Our convention is to use publ i c forthe constructors and methods in theAPI(since we are promising to provide them to clients) and private for everythingelse. Typically, our private methods are helper methods used to simplify code inother methods in the class. Java is not so restrictive on its usage of modifiers—wedefer to Section 3.3 a discussion of our reasons for these conventions.

Instance variables. Towrite code for the methods that manipulate data type values, the first thing that we need is to declare variables that we can use to refer tothese values in code. Thesevariables can be any type of data. Wedeclare the typesand names of these instance variables in the same wayaswe declarelocalvariables:for Charge, we use three double values, two to describe the charge's position inthe planeand one to describe the amount of charge. These declarations appearasthe first statements in the class, not inside mai n() or any other method. There is acritical distinction between instance variables and the local variables within a static

methodor ablock thatyouareaccustomed to:thereisjustone value correspondingto each local variable at a given time, but thereare numerous values corresponding to each instance variable (one for each object that is aninstance of the data type). There is no ambiguitywith this arrangement, because each time thatwe invoke an instance method, we do so with anobjectname—that object is the one whosevaluewe are manipulating.

public class Charge

{

modifiers

Instance variables

Constructors. A constructor creates an object and provides a reference to thatobject. Java automatically invokes a constructor when a client program uses thekeyword new. Java does most of the work: our code only needs to initialize theinstance variables to meaningful values.Constructors always share the same nameas the class, but we can overload the name and have multiple constructors withdifferentsignatures, just as with static methods. To the client, the combination of


access

modifierconstructor name

type (same asdnss name)argumentvariables

\ \_/_11 publ ic| [Charge! (| double xp" , double yO , double q0| )

finstance ^ rx = xO;

names ~"~ry - yv,

§ = qO;}

bodysignature

Anatomy of a constructor

new followed bya constructorname (withargument values enclosed within parentheses) is the sameasa function call that returnsa value of the corresponding type.A constructor signature has no return type, because constructors always returna reference to an object of its data type (the name of the type, the class, and theconstructor are all the same). Each time that a client invokes a constructor, Javaautomatically:

• Allocates memory spacefor the object• Invokes the constructor code to initialize the instance variables

• Returns a referenceto the objectThe constructor in Charge is typical: it initializes the instance variables with thevaluesprovided by the client as arguments.

Instance methods. To implement instance methods, we write code that is precisely likethe codethat welearned in Chapter 2 to implementstaticmethods (functions).Each method has a signature (which specifies its return type and the typesand names of its argumentvariables) and a body (which consists of a sequence of

local "_variables*

access return

modifier type

\ i

methodname

_\_

argumentvariables

Ipubl i clldoubl elIpotentialAtl(ldoubl e xl, [double vl)

' |double k | - 8. 99e09j__ argument variable name-[double dxl =1x1 - rx: • . • Mbz^z== '—' ^-- instance variable name[double dyl = y - |ry|;return k * q /|Math.sqrt(dx*dx + dy*[dyl) ;

call on a static method

Anatomyof an instance method

\local variable name

signature

373


statements, including a return statement that provides a value of the return typeback to the client). When a client invokes a method, the system initializesthe argument variables with client values; executes statements until reaching a returnstatement; and returns the computed value to the client, with the same effect as ifthe method invocation in the client werereplacedwith that return value.Allof thisaction is the same as for static methods, but there is one critical distinction for instance methods: they canperform operations on instance variables.

Variables within methods. Accordingly, the Java codethat wewrite to implementinstance methods uses three kinds of variables:

• Argument variables• Local variables

• Instance variables

The first two are the same as for staticmethods: argument variablesare specifiedinthe method signature and initialized with clientvalues when the method is called,and local variables are declared and initialized within the method body. The scopeof argument variables is the entire method; the scope of local variables is the following statements in the block where theyaredefined. Instance variables arecompletely different: they hold data-type values for objects in a class, and their scopeis the entire class. How do we specify which object's value we want to use? If youthink for a moment about this question, you will recall the answer. Each object inthe classhas a value: the code in a classmethod refers to the valuefor theobject thatwas used to invoke the method. When we say cl. potenti al At(x, y), the code inpotentialAt() is referring to the instance variables for cl. The code in poten-ti al At O uses all three kinds of variable names, as summarized in this table:

variable purpose example scope

instance specifydata-type value rx, ry class

argument passvaluefrom client to method x, y method

local temporaryusewithinmethod dx, dy block

Variables within instance methods

Be sure thatyou understand the distinctions among these three kinds of variables.These differences are a key to object-oriented programming.


$3?

m%**&•:

3&a

Program 3.2.1 Charged-particle implementation

public class Charge{

private final double rx, ry;private final double q;

public Charge(double xO, double yO, double qO){ rx = xO; ry = yO; q = qO; }

public double potentialAt(double x, double y){

double k = 8.99e09;double dx = x - rx;double dy = y - ry;return k * q / Math.sqrt(dx*dx + dy*dy);

}

public String toStringO{

k

dx, dy

electrostatic constant

delta distances to

querypoint••^m^^^^^^^^^^m:^m

}return q + " at " + "(" + rx + ", " + ry + ")'


double x = Double.parseDouble(args[0]);double y = Double.parseDouble(args[1]);Charge cl = new Charge(.51, .63, 21.3);Charge c2 = new Charge(.13, .94, 81.9);double vl = cl.potentialAt(x, y);double v2 = c2.potentialAt(x, y);StdOut.printf(M%.le\nM, (vl + v2));

}

x, y

cl

vl

c2

v2

query point

firstcharge

potential due to cl

second charge

potential due to c2

This implementation ofour data type for charged particles contains the basic elements foundin every data type: instance variables rx, ry, andq; a constructor Charge (); instance methodspotenti al At() and toStri ng(); anda test client mai n() (see also Program 3.1.1).


These are the basic components that you need to understand to be able to builddata types in Java. Every data-type implementation (Java class) that we will consider has instance variables, constructors, instance methods, and a test client. In

eachdata type that wedevelop, wegothrough the samesteps.Rather than thinkingabout what action we need to take next to accomplish a computational goal (as wedid when first learning to program), we think about the needs of a client, then accommodate them in a data type.

The first step in creating a data type is to specify an API.The purpose of theAPI is to separate clients from implementations, to enable modular programming.Wehavetwo goals when specifying an API. First,we want to enable clear and correct client code.Indeed, it is a good idea to write some client code before finalizingthe APIto gainconfidence that the specified data-type operations are the ones thatclients need. Second,we want to be able to implement the operations. There is nopoint specifying operations that wehave no ideahow to implement.

The secondstep in creatinga data type is to implement a Java class that meetsthe API specifications. First, we choose the instance variables, then we write thecode that manipulatesthe instancevariables to implement the specified methods.

The third step in creating a data type is to write test clients, to validate thedesign decisionsmade in the first two steps.

In this section,we start each example with an API, and then consider implementations, then clients. You will find many exercises at the end of this sectionintended to give you experience with data-type creation.Section 3.3 is an overviewof the design processand relatedlanguage mechanisms.

What are the valuesthat definethe type, and what operations do clients needto perform on those values? With these basic decisions made, you can create newdata types and write clients that use the data types that you have defined in thesame wayas you have been using built-in types.


public class Charge

{

instance

variables

constructor -

instance

methods

test client

create

andinitialize"

object

private final double rx, ry;private final double q;

public Charge(double xO, double yO, double qO){ rx = xO; ry = yO; q = qO; }

public double potentialAt(double x, double y)

{ ^^^^ instancedouble k = 8.99e09; ^—-~ variable

double dx = x - rx ; names

double dy = y - ry;return k * q / Math.sqrt(dx*dx +

}

dy*dy)/

public String toString(){ return q +" at " + "("+ rx + ", " + ry +")"; }


{double x = Double.parseDouble(args[0])double y = Double.parseDouble(args[1])Charge cl =|new Charge(.51, .63, 21.3)Charge c2 = new Charge(.13, .94, 81.9); \

double vl = cl. potential At (x, y) ; invokedouble v2 =| c2. potenti al At ( x, y); constructorStdOut.prin/f("%.le\n", (vl + v20);

objectname

Anatomy ofa class

invokemethod

377


Stopwatch One of the hallmarks of object-oriented programming is the ideaof easily modeling real-world objects by creating abstract programming objects.As a simple example, consider Stopwatch (Program 3.3.2), which implements thefollowing API:

public class Stopwatch

Stopwatch () create a newstopwatch andstartit running

doubl e el apsedTi me() return the elapsed time since creation, in seconds

APIforstopwatches {see Program 3.2.2)

In other words, a Stopwatch is a stripped-down version of an old-fashioned stopwatch.When you create one, it starts running, and you can ask it how long it hasbeen running by invokingthe method el apsedTi me (). You might imagine addingall sorts of bells and whistles to Stopwatch, limited only by your imagination. Doyou want to be able to reset the stopwatch? Start and stop it? Include a lap timer?Thesesorts of things are easyto add (seeExercise 3.2.11).

The implementation in Program 3.2.2 uses the Javasystem method System,cur ren tTi meMi 11i s (), which (aswell-describedby its name) returns along valuegiving the current time in milliseconds (the number of milliseconds since midnight on January 1, 1970 UTC). The data-type implementation could hardly besimpler.A Stopwatch saves its creation time in an instance variable, then returnsthe difference between that time and the current time whenever a client invokes

its el apsedTi me () method. A Stopwatch itself does not actually tick (an internalsystemclock on your computer does all the ticking for all Stopwatch objects andmany other data types); it just creates the illusion that it does for clients. Why notjust use System. cur rentTi meMi 11 i s () in clients? We could do so, but using thehigher-level Stopwatch abstraction leadsto client code that is easier to understandand maintain.

The test client is typical. It creates two Stopwatch objects, uses them to measure the running time of two different computations, then prints the ratio of therunning times. The question of whether one approach to solvinga problem is better than another has been lurking since the first few programs that you have run,and playsan essential role in program development. In Section 4.1,wewill developa scientific approach to understanding the cost of computation. Stopwatch is auseful tool in that approach.


Pit Program3.2.2 Stopwatch

public class Stopwatch{

private final long start;

public Stopwatch(){ start = System.currentTimeMillisQ; }

}

public double elapsedTime(){

long now = System.currentTimeMillis();return (now - start) / 1000.0;

}


int N = Integer.parselnt(args[0]);

double totalMath =0.0;Stopwatch swMath = new Stopwatch();for (int i = 0; i < N; i++)

total Math += Math.sqrt(i);double timeMath = swMath.elapsedTime();

double totalNewton = 0.0;Stopwatch swNewton = new Stopwatch();for (int i = 0; i < N; i++)

total Newton += Newton.sqrt(i);double timeNewton = swNewton.elapsedTime();

StdOut.pri ntln(total Newton/totalMath);StdOut.pri ntln(ti meNewton/ti meMath);

This class implements a simple data type that wecan use to compare running times ofperformance-critical methods (see Section 4.1). The test client compares the method for computingsquare roots in Java's Math library with our implementation from Program 2.1.1 that usesNewton's methodfor the task of computing thesumof thesquare roots of the numbers from 0toN-l. For this quick test, theJava implementation Math.sqrt () isabout20 timesfasterthanour Newton. sq rt () (as it should be!).

% java Stopwatch 10000001.0

19.961538461538463

•mmm S"*3$^P••^^SJP^^S^Vs^SJr*^?^)^;y^^^Jm^^^^^^^^^^^^^'

379

mi


Histogram Data-typeinstance variables can be arrays. As an illustration, consider Histogram (Program 3.2.3), which maintains an array of the frequency ofoccurrence of integer values in a given interval [0, N) and uses StdStats. plot-Bars () to display a histogram of the values, controlled by this API:

public class Histogram

Histog ram(i nt N) create a dynamic histogram for theN int values in [0y N)

double addDataPoint(int i) addan occurrence of thevalue i

voi d draw() draw thehistogram usingstandard draw

APIfor histograms {see Program 3.2.3)

Bycreatinga simple class such as Hi stog ram, we reap the benefits of modular programming (reusable code, independent development of small programs, and soforth) that we discussed in Chapter 2,with the additional benefit that we also separate the data. A histogram client need not maintain the data (or know anythingabout its representation); it just creates a histogram and calls addDataPoi nt ().

When studying this code and the next severalexamples, it is best to carefullyconsider the client code. Each class that we implement essentially extends the Javalanguage, allowing us to declare variables of the new data type, instantiate themwith values,and perform operations on them. Allclient programs are conceptuallythe same as the first programs that you learned that use primitive types and built-in operations. Now you have the ability to define whatever types and operationsyou need in your client code! In this case,using Hi stog ram actually enhances readabilityof the client code,as the addDataPoi nt () call focuses attention on the databeing studied.Without Hi stog ram, wewould haveto mix the code for creating thehistogram with the code for the computation of interest, resulting in a programmuch more difficult to understand and maintain than the two separate programs.Whenever you can clearly separate dataand associated operations within a program,you shoulddo so.

Once you understand how a data type will be used in client code, you canconsider the implementation. An implementation is characterized by its instancevariables (data type values). Hi stog ram maintains an array with the frequency ofeach point and a doubl e value max that stores the height of the tallest bar (for scaling). Its private drawQ method scales the drawing and then plots the frequencies.


m^^^s^^^M^^^^sm^^m^^^mmmm

Program 3.2.3 Histogram


private final doubled freq; freq[]private double max; max

public Histogram(int N){ // Create a new histogram.

freq = new double[N];}

public void addDataPoint(int i){ // Add one occurrence of the value i.

freq[i]++;if (freq[i] > max) max = freq[i];

}

public void draw(){ // Draw (and scale) the histogram.

StdDraw.setYscale(0, max);StdStats.piotBars(freq);

}

public static void main(String[] args){ // See Program 2.2.6.

int N = Integer.parselnt(args[0]) ; ">^^^^^^^^^^^^int T = Integer.parselnt(args[1]);Histogram histogram = new Histogram(N+l);for (int t = 0; t < T; t++)

hi stogram.addDataPoi nt(Bernoul1i.bi nomi al(N));StdDraw.setCanvasSize(500, 100);histogram.draw();

}

frequency counts

maximumfrequencymm^m.

% java Histogram 50 1000000

This data type supports simple client code to create dynamic histograms of thefrequency ofoccurrence of values in [0, N). Thefrequencies are kept in an instance-variable array and aninstance variable max tracks the maximum frequency (forscaling). To make a dynamicallychanging histogram, adda call to StdDraw.cl ear () before and a call to StdDraw. show(20)after thecall to hi stogram. drawQ in theclientcode..


Turtle graphics Whenever you can clearly separate tasks within a program, youshould do so. In object-oriented programming, we extend that mantra to includestate with the tasks.A small amount of state can be immensely valuable in simplifying a computation. Next, we consider turtle graphics, which is based on the datatype defined by this API:

public class Turtle

-i-.ui^jlt rtJUT rt-ii-n ^ create a new turtle at (xn, yn) facing anTurtle(double xO, double yO, double aO) , , , • / , .

degreescounterclockwisefrom the x-axis

void turnLeft (double delta) rotate delta degrees counterclockwise

voi d goForward(doubl e step) move distance step, drawing a line

APIfor turtle graphics (seeProgram 3.2.4)

Imagine a turtle that lives in the unit square and draws lines as it moves. It canmove a specifieddistance in a straight line, or it can rotate left (counterclockwise)a specified number of degrees. According tothe API, when we create a turtle, we place it ata specified point, facing a specified direction.Then, we create drawings by givingthe turtle asequence of goForwardO and turnLeft()commands.

For example, to draw a triangle we createa Turtl e at (0, .5) facing at an angle of 60 degrees counterclockwise from the origin, thendirect it to take a step forward, then rotate 120degrees counterclockwise, then take anotherstep forward, then rotate another 120 degreescounterclockwise, and then take a third stepforward to complete the triangle. Indeed, all ofthe turtle clients that we will examine simplycreate a turtle, then giveit an alternating seriesof step and rotate commands, varying the stepsize and the amount of rotation. As you willsee in the next severalpages,this simple model

double xO = 0.5;double yO = 0.0;double aO = 60.0;double step = Math sqrt(3)/2;Turtle t = new Turtle(x0, yo,t.goForward(step);

(x0,y0)

aO);

A turtle's first step

(*n


allows us to create arbitrarily complex drawings, with many important applications.

Turtle (Program 3.2.4) is an implementation of this APIthat uses StdDraw. It maintains three instance variables: the co

ordinates of the turtle's position and the current direction it isfacing, measured in degrees counterclockwise from the x-axis.Implementing the two methods requires updating the values

of these variables, so they are notfinal. The necessary updates arestraightforward: tu rnLeft (del ta)adds delta to the current angle, andgoForward(step) adds the step sizetimes the cosine of its argument to thecurrent x-coordinate and the step sizetimes the sine of its argument to thecurrent y-coordinate.

The test client in Tu rt1 e takes an

integer Nas command-line argumentand draws a regular polygon with Nsides. If you are interestedin elementary analytic geometry,you might enjoyverifying thatfact. Whether or not you choose to do so, think about what youwould need to do to compute the coordinates of all the points inthe polygon. The simplicity of the turtle's approach is very appealing. In short, turtle graphics servesas a useful abstraction fordescribing geometric shapes of all sorts. For example, we obtaina good approximation to a circle by taking N to a sufficientlylarge value.

Youcan use a Turt1e asyou use any other object. Programscan create arrays of Turtle objects, pass them as arguments tofunctions, and so forth. Our examples will illustrate these capabilities and convinceyou that creating a data type likeTurtl e isboth very easy and very useful. For each of them, as with regular polygons, it is possible to compute the coordinates of all thepoints and draw straight lines to get the drawings,but it is easierto do so with a Turtle. Turtle graphics exemplifies the value ofdata abstraction.

(x0 + d cosa, y0 + d sin a)

dsina

Turtle trigonometry

t.goForward(step);

t.goForward(step);

t.goForward(step);

Yourfirst turtlegraphics drawing

383


Program 3.2A Turtle graphics

mW.

si

«5*

Si

X-.':,

1

public class Turtle{

private double x, y;private double angle;

public Turtle(double xO, double yO, double aO){ x = xO; y = yO; angle = aO; }

public void turnLeft(double delta){ angle += delta; }

public void goForward(double step){ // Compute new position, move and draw line to it.

double oldx = x, oldy = y;x += step * Math.cos(Math.toRadians(angle));y += step * Math.sin(Math.toRadians(angle));StdDraw.line(oldx, oldy, x, y);

}

public static void main(String[] args){ // Draw an N-gon.

int N = Integer.parselnt(args[0]);double angle = 360.0 / N;double step = Math.sin(Math.toRadians(angle/2));Turtle turtle = new Turtle(.5, .0, angle/2);for (int i = 0; i < N; i++){

turtle.goForward(step);turtle.turnLeft(angle);

}}

x, y

angle

position (in unit square)

direction of motion (degrees,counterclockwisefrom x axis)

1ft

mftp

&#3

"if"

?&•:>•

m

This data type supports turtle graphics, which often simplifies thecreation of drawings.


Recursive graphics. A Koch curve of order 0 is a straight line. To form a Kochcurve of order n, draw a Koch curve of order n-1, turn left 60 degrees, draw asecond Kochcurve of order n-1, turn right 120degrees (left -120 degrees),draw athird Kochcurve of order n-1, turn left 60 degrees, and draw a fourth Kochcurveof order n-1. These recursive instructions lead immediately to turtle client code.With appropriate modifications, recursive schemes likethis have proven useful inmodeling self-similarpatterns found in nature, such as snowflakes.

The client code below is straightforward,exceptfor the value of the step sizesz. If you carefully examine the first few examples, you will see (and be able toprove by induction) that the width of the curve of order n is 3"times the step size,so settingthe step size to 1/3"produces a curveofwidth 1.Similarly, the number ofstepsin a curveof order n is 4M, so Koch willnot finish if you invoke it for largen.

You can find many examples of recursive patterns of this sort that have beenstudied and developed by mathematicians, scientists, and artists from many cultures in many contexts. Here, our interest in them is that the turtle graphics abstraction greatlysimplifies client code that drawsthem.

public class Koch 0{

public static void koch(int n, double step, Turtle turtle){

if (n == 0)

{ 1turtle.goForward(step); Areturn; / \

koch(n-l, step, turtle); 0turtle.turnLeft(60.0);koch(n-l, step, turtle); r^yturtle. turnl_eft(-120.0); —/w V^\_koch(n-l, step, turtle);turtle.turnLeft(60.0); 3koch(n-l, step, turtle); .a/^Ls

} ^iJIjVpublic static void main(String[] args)

t 4int n = Integer, parselnt(args [0]); «*•***•*»double step = 1.0 / Math.pow(3.0, n); **t r S s*tTurtle turtle = new Turtle(0.0, 0.0, 0.0); *" w w **"koch(n, step, turtle);

}

Drawing Koch curves with turtle graphics


Spira mirabilis. Perhaps the turtleisabit tiredafter taking 4"steps to drawa Kochcurve.Accordingly, imagine that the turtle's step sizedecays by a tiny constant factor eachtime that it takesa step. Whathappensto our drawings? Remarkably, modifying the polygon-drawing test client in Program 3.2.4 to answer this questionleadsto an imageknown asa logarithmic spiral, a curvethat is found in manycontexts in nature.

Spi ral (Program 3.2.5) is an implementation of this curve. It takes Nand thedecayfactorascommand-line argumentsand instructs the turtle to alternatelystepand turn until it has wound around itself 10 times. As you can see from the fourexamples given with the program,the path spirals into the center of the drawing.The argument Ncontrols the shapeof the spiral.You are encouragedto experimentwith Spi ral yourself in order to develop an understanding of the wayin which theparameters control the behavior of the spiral.

The logarithmic spiral was first described by Rene Descartes in 1638.JacobBernoulliwasso amazedby its mathematicalproperties that he named it the spiramirabilis (miraculous spiral) and evenasked to have it engraved on his tombstone.Many people also consider it to be "miraculous" that this precise curve is clearlypresent in a broad variety of natural phenomena. Three examples are depicted below: the chambers of a nautilus shell, the arms of a spiral galaxy, and the cloudformation in a tropical storm. Scientists have also observed it as the path followedbya hawkapproachingits preyand the path followed by a chargedparticle movingperpendicular to a uniform magnetic field.

One of the goalsof scientificenquiry is to provide simple but accurate modelsof complex natural phenomena. Our tired turtle certainly passes that test!

nautilus shell galaxy storm

Examples of thespira mirabilis in nature


••¥J:SI

m

Program 3.2.5 Spiramirabilis

public class Spiral{


int N = Integer.parselnt(args[0]);double decay = Double.parseDouble(args[l]);double angle = 360.0 / N;double step = Math.sin(Math.toRadians(angle/2));Turtle turtle = new Turtle(0.5, 0, angle/2);

for (int i = 0; i < 10 * 360 / angle; i++){

step /= decay;turtle.goForward(step);turtle.turnLeft(angle);

}

This code isa modification ofthe test client inProgram 3.2.4 that decreases the step size ateachstep andcycles around 10times. The angle controls the shape; the decay controls the nature ofthespiral.

% java Spiral 3 1.0

java Spiral 3 1.2

'^HSW^^K^SS^S?i^^^^^^^^SIS^P


Brownian motion. Or, perhaps the turtle has had one too many. Accordingly,imagine that the disoriented turtle (again following its standard alternating turnand stepregimen) turns in a random direction before eachstep. Again, it is easy toplot the path followed by such a turtle for millions of steps, and again, such pathsare found in nature in many contexts. In 1827, the botanist Robert Brownobservedthrough a microscope that pollengrainsimmersed in water seemedto moveaboutin just such a random fashion, which later became known as Brownian motion andled to Albert Einstein's insights into the atomic nature of matter.

Or perhaps our turtle has friends, all of whom have had one too many. Aftertheyhave wandered aroundfora sufficiently longtime, theirpathsmerge togetherand become indistinguishable from a single path. Astrophysicists todayare usingthis model to understand observed propertiesof distant galaxies.

Turtle graphics was originally developed by Seymour Papert at MIT in the 1960sas part of an educational programming language, Logo, that is stillused today intoys. But turtle graphics is no toy, as we have just seen in numerous scientific examples. Turtlegraphics also has numerous commercial applications. For example,it is the basis for PostScript, a programming language for creating printed pagesthat is used for most newspapers, magazines, and books. In the present context,Turtle is a quintessential object-oriented programming example, showing that asmallamount of saved state (data abstraction using objects,not just functions) canvastly simplify a computation.

10000 .01

public class DrunkenTurtle{


int T = Integer.parselnt(args[0]);double step = Double.parseDouble(args[l]);Turtle turtle = new Turtle(0.5, 0.5, 0.0);for (int t = 0; t < T; t++){

turtle.turnLeft(360.0 * Math.random());turtle.goForward(step);

}}

}

Brownian motion ofa drunken turtle (moving afixeddistance in a random direction)


public class DrunkenTurtles{


int N = Integer.parselnt(args[0]);int T = Integer.parselnt(args[l]);double step = Double.parseDouble(args[2]);Turtle[] turtles = new Turtle[N];for (int i = 0; i < N; i++)

turtles[i] = new Turtle(Math.random(), Math.random(),for (int t = 0; t < T; t++){ //All turtles take one step.

for (int i = 0; i < N; i++){ // Turtle i takes one step in a random direction.

turtles[i] .turnl_eft(360.0 * Math, random()) ;tu rtles[i].goForward(step);

}

}}

20 500 .005 20 5000 .005

? £r *|

20 1000 .005

// number of turtles// number of steps// step size

0.0);

Brownian motion ofa bale ofdrunken turtles

389


Complexnumbers Acomplex number is a number ofthe form x+ iy, where xand y are real numbers and i is the squareroot of -1. The number x is known asthereal partof thecomplex number, andthenumber y isknown as the imaginarypart.This terminology stems from the idea that the square root of -1 hasto be animaginary number, because no real number canhave thisvalue. Complex numbersare a quintessential mathematical abstraction: whether or not one believes that itmakes sense physically to take the square root of -1, complex numbers help usunderstand the natural world. They are used extensively in applied mathematicsand play an essential role in many branches of science and engineering. They areused to model physical systems of all sorts, from circuits to sound waves to electromagnetic fields. These models typically require extensive computations involvingmanipulating complex numbers according to well-defined arithmetic operations,so wewant to write computer programs to do the computations. In short, we needa new data type.

Developing a data type for complex numbers is a prototypical example ofobject-oriented programming. No programming language canprovide implementations of every mathematical abstraction that we might need, but the ability toimplement datatypes give usnot justtheability to write programs to easily manipulate abstractions such as complex numbers, polynomials, vectors, matrices, butalso the freedom to think in terms of new abstractions.

Theoperations on complex numbers that areneeded for basic computationsare to add and multiply them by applying the commutative, associative, and distributive laws of algebra (along with the identity i2 = -1); to compute the magnitude; and to extract the real andimaginary parts, according to the following equations:

•Addition: (x+iy) + (v+iw) = (x+v) + i(y+w)• Multiplication: (x+ iy) * jv+ iw) = (xv-yw) + i(yv + xw)•Magnitude: \x + iy \= Jx2 +y2• Real part Re(x + iy)=x• Imaginary part Im(x +iy)=y

For example, if a = 3 + 4i and b=-2 + 3i,then a +b= 1 + li, a *b = -18 + i,Re(a)= 3, Im(a) = 4, and \a\ = 5.

With these basic definitions, the path to implementing a data typefor complex numbers is clear. As usual, we startwith an API that specifies the data-typeoperations:


public class Complex

Complex(double real, double imag)

Complex pi us(Complex b)

Complex times(Complex b)

double abs()

double re()

double im()

String toString()

sumof this number and b

product of this number and b

magnitude

realpart

imaginary part

stringrepresentation

APIfor complex numbers (see Program 3.2.6)

For simplicity, we concentrate in the text on just the basic operations in this API,but Exercise 3.2.19asksyou to consider several other usefuloperations that mightbe included in such an API.

Compl ex (Program 3.2.2) is a class that implements this API. It has all of thesame components as did Charge (and everyJava data type implementation): instance variables (re and im), a constructor, instance methods (plus(), times(),abs (), re (), i m(), and toSt ri ng()), and a test client.The test client first sets z0 to1 + i, then setsz to z0, and then evaluates:

Z= Z2 + Zq = (i + i)2 + (i + {) = (! + 2i -1) + (1 + i) = 1 + 3*z = z2 + Zq = (! + 3Q2 + (l + i) = (1 + 6i -9) + (1 + i) = -7 + li

This code is straightforwardand similar to code that you have seen earlier in thischapter, with one exception: the code that implements the arithmetic methodsmakes use of a new mechanism for accessing object values.

Accessing instance variables in objects of this type. Both plus() and times()need to access values in two objects: the object passed as an argument and theobject used to invoke the method. If we call the method with a. pi us (b), we canaccess the instance variables of a using the names re and i m, as usual, but to accessthe instance variables of of b we use the code b. re and b. i m. Keeping the instancevariables private means that client code cannot access directly instance variables inanother class (but code in the same class can access any object's instance variablesdirectly).

391


Chaining. Observe the manner in which main() chains two method calls intoone compact expression: the expression z. ti mes (z). pi us (zO) evaluates to z2 +zQ. This usage is convenient because we do not have to invent a variable name forthe intermediate value. If you study the expression, you can see that there is noambiguity: moving fromleftto right,each method returns a reference to a Compl exobject, which is used to invoke the next method. If desired, we can use parenthesesto override the default precedence order (for example, z. ti mes (z. pi us(zO) )evaluates to z{z+ z0)).

Creating and returning new objects. Observe the manner in which pius() andtimesO providereturn values to clients: they need to return a Complex value, sotheyeachcompute the requisite real and imaginary parts,usethem to create a newobject, and then return a reference to that object. Thisarrangement allow clients tomanipulate complex numbers bymanipulating local variables of type Compl ex.

Final values. The two instance variables inCompl ex are fi nal,meaning that theirvalues are setforeach Compl exobject when it iscreated anddo not change duringthelifetime of an object. Again, we discuss the reasons behind thisdesign decisionin Section 3.3.

Complex numbers are the basis for sophisticated calculations from applied mathematics that have many applications. Some programming languages have complexnumbers built in asa primitive type, andprovide special language supportfor useofoperators such as*and+to perform addition, multiplication, andotheroperations, in the same way asfor integers or floating-point numbers. Java does not support overloadingfor built-in operators. Java's support for data types is much moregeneral, allowing us to compute withabstractions of alldescription. Compl ex isbutone example.

To give you a feeling for the nature of calculations involving complex numbers and the utility of the complexnumber abstraction, we next consider a famousexample of a Compl ex client.


l^^^g^^^^îi^^^Miîligîiiiliil

Program 3.2.6 Complex numbers

public class Complex{

private final double re;private final double im;

public Complex(double real, double imag){ re = real; im = imag; }

public Complex pi us(Complex b){ // Return the sum of this number and b.

double real = re + b.re;double imag = im + b.im;return new Complex(real, imag);

}

public Complex times(Complex b){ // Return the product of this number and b

double real =re*b.re-im*b.im;double imag = re * b.imreturn new Complex(real, imag);

}

public double abs(){ return Math.sqrt(re*re + im*im);

public double re()public double im()

{ return re;{ return im;

public String toString(){ return re + " + " + im


Complex zO = new Complex(1.0, 1.0);Complex z = zO;z = z.times(z).plus(zO);z = z.times(z).plus(zO);StdOut.println(z);

}

This data type is the basis for writing Java programs that manipulate complex numbers.


Mandelbrot set The Mandelbrot set is a specific set of complex numbers discovered by Benoit Mandelbrot. It has many fascinating properties. It is a fractalpattern that is related to the Barnsley fern, the Sierpinski triangle, the Brownianbridge, the Koch curve, the drunken turtle, and other recursive (self-similar) patterns and programs that we have seen in this book. Patterns of this kind are foundin natural phenomena ofall sorts, andthese models and programs arevery important in modern science.

Thesetof pointsin theMandelbrot setcannotbe described bya single mathematical equation. Instead, it is defined by an algorithm, and therefore a perfectcandidate for a Compl ex client: we studythe setbywritingprograms to plot it.

Therule for determining whether a complex number z0 is in the Mandelbrotsetissimple: Consider thesequence ofcomplex numbers z0, zx, z2,..., zt,..., wherezt+i = (zt¥ + zo- F°r example, this table shows the first few entries in the sequencecorresponding to z0 =1 + i:

* zt (^ W+Zp0 1 + / 1+ 2/+ /2 = 2/ 2/+(l + /) = 1+3/

1 1 + 3/ 1+ 6i+ 9i2 =-8 + 6/ -8 + 6/ + (1 + i) = -7 + li

2 -7 + 7i 49 - 98/ + 49i2 = —98i -98* + (1 + i) = 1- 97/

Mandelbrot sequence computation

Now, if thesequence \zt\ diverges to infinity, then z0 is not in the Mandelbrot set; ifthe sequence isbounded,then z0is in the Mandelbrot set. Formanypoints,the testis simple; for many other points, the test requires more computation, as indicatedby the examples in this table:

0 + 0/ 2 + 0/ 1 + / -.5 + 0/ .10 - .64/

0 0 + 0i 2 + 0i 1 + i -.5 + 0* .10- Mi

1 0 + 0/ 6 + 0i l + 3i -.25 + Oi -.30- .Hi

2 0 + 0i 36 + Oi -7 + li -.44 + Of -.40- .18i

3 0 + 0i 1446 + Oi 1 - 97*' -.31 + Oi .23- .50*

4 0 + 0i 2090918 + 0/ - 9407 - 193*' -.40 + Oi -.09- .87i

in the set? yes no no yes yes

Mandelbrot sequenceforseveral startingpoints


.64/

Mandelbrot set

For brevity, the numbers in the rightmosttwo columns of this table are given to justtwo decimal places.In some cases,we canprove whether numbers arein the set: for example, 0 +0/ is certainly in the set (sincethe magnitude of all thenumbers in its sequence is0), and 2 + 0/ is certainly notin the set (since its sequencedominates the powers of 2,which diverges). In someother cases, the growth isreadily apparent: for exam

ple, 1 + / does not seem to be in the set. Other sequences exhibit aperiodicbehavior: for example, / maps to —1 + i to —i to —1 + / to—/.... And some sequences go on for a very long time before themagnitude of the numbers beginsto get large.

To visualize the Mandelbrot set, we sample complex points, justas we sample real-valued points to plot a real-valued function. Eachcomplex number x+ iy corresponds to a point (x, y) in the plane,so we can plot the results as follows: for a specified resolution N, wedefinea regularly spacedN-by-Npixel grid within a specified squareand draw a blackpixelif the correspondingpoint is in the Mandelbrotset and a white pixel if it is not. This plot is a strangeand wondrouspattern, with all the blackdots connected and falling roughly withinthe 2-by-2 square centered on the point -1/2 + 0/. Large values ofN will produce higher-resolution images, at the cost of more computation. Looking closerreveals self-similarities throughout the plot.For example, the same bulbous pattern with self-similar appendagesappears all around the contour of the main blackcardioid region, ofsizesthat resemble the simple ruler function of Program 1.2.1. Whenwe zoom in near the edge of the cardioid, tiny self-similar cardioidsappear!

But how, precisely, do we produce such plots? Actually, no oneknows for sure, because there is no simple test that would enable us to

395

1015 -.633 1.0

.1015 -.633

Zoomingin on theset


conclude that a point is surely in the set. Given a complex point, we cancomputethe terms at the beginning of its sequence, but may not be able to knowfor surethat thesequence remains bounded. There isa testthat tells us forsurethat a pointis not in the set: if the magnitude of any number in the sequence evergets to begreater than 2 (such as2 + Oi), then the sequence surely will diverge.

Mandelbrot (Program 3.2.7) uses this test to plot a visual representation ofthe Mandelbrot set. Since our knowledge of the set is not quite black-and-white,we use grayscale in our visual representation. It is based on the function mand () (aCompl ex client), which takes a Compl exargument zO and an i nt argumentmax andcomputes the Mandelbrot iteration sequence startingat zO, returning the numberof iterations for which the magnitude stays less than 2,up to the limit max.

For each pixel, the method main() in Mandelbrot computes the point zOcorresponding to the pixeland then computes 255 - mand (zO, 255) to create agrayscale colorfor the pixel. Any pixel that is not blackcorresponds to a point thatweknowto be not in the Mandelbrot set because the magnitude of the numbersin its sequence grew past 2 (and therefore will go to infinity). The black pixels(grayscale value 0) correspond to points that we assume to be in the set becausethe magnitude stayed less than 2for255 iterations, but wedo not necessarily knowfor sure.

The complexity of the images that this simpleprogram produces is remarkable, evenwhenwezoomin on a tinyportion of the plane.For evenmore dramaticpictures, we can use use color (see Exercise 3.2.34). And the Mandelbrot set is derived from iteratingjust one function (z2 + z0): we have a great deal to learn fromstudying the properties of other functions, as well.

Thesimplicity of thecodemasks a substantial amount of computation. Thereare about one-quarter million pixels in a 512-by-512 image, and all of the blackones require255iterations,so producingan imagewith Mandel brot requireshundreds of millions of operations on Compl ex values.

Fascinating as it is to study, our primary interest in Mandel brot is as an exampleclientof Compl ex, to illustrate that computingwith a type of data that isnotbuilt into Java (complex numbers) is a natural and useful programming activity.Mandel brot isa simple and naturalexpression of the computation, madesobythedesign and implementation of Compl ex.You could implement Mandel brot without usingCompl ex, but the codewouldessentially have to mergetogether the codein Programs 3.2.6 and 3.2.7 and therefore would be much more difficult to understand. Whenever you can clearly separate tasks within aprogram, you should do so.


msmmmmsmmmmmmm^

Program 3.2.7 Mandelbrot set


public class Mandelbrot{

private static int mand(Complex zO, int max){

Complex z = zO;for (int t = 0; t < max; t++)

{if (z.absO > 2.0) return t;z = z.times(z).plus(zO);

}return max;

}


double xc = Double.parseDouble(args[0]);double yc = Double.parseDouble(args[l]);double size = Double.parseDouble(args[2]);int N = 512;Picture pic = new Picture(N, N);for (int i = 0; i < N; i++)

for (int j = 0; j < N; j++){

double xO = xc - size/2 + size*i/N;double yO = yc - size/2 + size*j/N;Complex zO = new Complex(xO, yO);int t = 512 - mand(z0, 512);Color c = new Color(t, t, t);pic.set(i, N-l-j, c);

}pic.showQ;

}

m

xO, yO point in square

zO x0+ iy0max iteration limit

xc, yc center of squaresize squareis size-by-size

N grid is N-by-N pixelspic imagefor output

c pixel colorfor output^"^^^^^^^^^yw^^^^^mm^^^i-

-.5 0 2

-.1015 -.633 .01

PPP

This program takes three command-line arguments thatspecify the center andsizeofa squareregion of interest, and makes a digital image showing the result ofsampling theMandelbrot setin thatregion at a 512*512 gridof equally spaced pixels. It colors each pixel with a grayscalevalue thatis determined bycounting the number of iterations before theMandelbrot sequencefor thecorresponding complex number grows past 2.0, up to 255.

m

&i"


Commercial data processing One of thedriving forces behind the development of object-orientedprogramminghas been the need for an extensive amountof reliable software for commercial data processing. As an illustration,weconsidernext an example of a data typethat mightbe usedby a financial institution to keeptrack of customer information.

Suppose that a stock broker needs to maintain customer accounts containing shares of various stocks. That is, the set of values the broker needs to processincludes the customer's name, numbers of different stocks held, amount of sharesand tickersymbolsfor each,and perhaps the total valueof the stocksin the account.Toprocessan account, the broker needs at least the operations defined in this API:

public class StockAccount

StockAccount(In in)create a new accountfrominformation in inputstream

doubl e val ue() total value in dollars

void buy (int amount, String symbol) addshares ofstock toaccount

doubl e sel 1(i nt amount, Stri ng symbol) subtract shares ofstockfrom account

voi d wri te (Out out) save account toan output stream

voi d pri ntReport () printa detailed report ofstocks andvalues

APIforprocessing stock accounts {see Program 3.2.8)

The broker certainlyneeds to buy,sell, and provide reports to the customer,but thefirstkeyto understanding this kind of data processing is to consider the StockAccount () constructor and the wri te () method in this API. The customer information has a long lifetime and needs to be saved in a file or database. To process anaccount, a client program needs to read information from the correspondingfile;process the information as appropriate; and, if the information changes, write itbackto the file, saving it for later. To enable this kind of processing, we need afileformatand an internal representation, or a datastructure, for the account information. The situation is analogous to whatwesawfor matrix processing in Chapter 1,wherewe defined a file format (numbersof rows and columns followed by entriesin row-majororder) and an internal representation (Java two-dimensional arrays)to enable us to writeprograms for the random surferand other applications.


As a (whimsical) running example,we imagine that a broker is maintaining asmall portfolio of stock in leading softwarecompanies for Alan Turing, the fatherof computing. Asan aside: Turing's life story is a fascinating one that is worth pursuing.Among many other things,he workedon computational cryptography thathelpedto bring about the end of the Second World War, he developed the basisformodern theoretical computer science, he designed and built one of the first computers, and he was a pioneer in artificial intelligence research. It is perhaps safe toassume that Turing, whatever his financial situation as an academic researcher inthe middle of the last century, would be sufficiently optimistic about the potentialimpact of computing software in today's world that he would make some smallinvestments.

399

Fileformat. Modern systems normally usetextfiles, even for data,to minimize dependence on formats defined by any one program.For simplicity, we use a direct representation where we list the account holder's name (a string), cash balance (a floating-point number), and number of stocks held (an integer), followedby a line foreach stock giving the number of shares and the ticker symbol. It isalso wise to use tags such as <Name> and <Number of shares>andso forth to label all the information, to further minimize dependencies on any one program, but we omit tags here for brevity.

% more Turing,.txt

Turing, Alan10.24

5

100 ADBE

25 G00G

97 IBM

250 MSFT

200 YH00

Fileformat

Data structure. Torepresent information for processingby Javaprograms, we useobject instance variables. They specify the type of infer-mation and provide the structure that we need in orderto clearly refer to it in code. For our example, we clearlyneed the following:

• A Stri ng value for the account name• A doubl e value for the cash balance

• An i nt value for the number of stocks

• An array of Stri ng values for stock symbols• An array of i nt values for numbers of shares

We directly reflect these choices in the instance variabledeclarations in StockAccount (Program 3.2.8). Thearrays stocks [] and shares [] are known as parallel arrays. Given an index i,stocks [i ] gives a stock symbol and shares [i ] give the number of shares of that

public class StockAccount{

private final String name;private double cash;private int N;private int[] shares;private String[] stocks;

}

Data structure blueprint


stock in the account. An alternative designwould be to define a separate data typefor stocks to manipulate this information for each stock and maintain an array ofobjects of that type in StockAccount.

StockAccount includes a constructor, which reads a file and builds an accountwith this internal representation, and the method implementation for value(),which uses StockQuote (Program 3.1.10) to get each stock's price from the web.For example, our broker needs to provide a periodic detailed report to customers,perhaps using the following code for pri ntReport () in StockAccount:

public void printReport(){

StdOut.printfC'XsXn", name);StdOut.printf(" Cash: $%9.2f\n", cash);double total = cash;for (int i = 0; i < N; i++)

{int amount = shares[i];double p = StockQuote.price(stocks[i]);StdOut.printf("%4d %4s ", amount, stocks[i]);StdOut.printf(" $%6.2f $%9.2f\n", p, amount * p);total += amount * p;

}StdOut.printf(" Total: $%9.2f\n", total);

}

On the one hand, this client illustrates the kind of computing that was one of theprimary drivers in the evolution of computing in the 1950s.Banks and other companies bought early computers preciselybecause of the need to do such financialreporting. For example,formatted printing was developed preciselyfor such applications. On the other hand, this client exemplifies modern web-centric computing,as it gets information directlyfrom the web,without using a browser.

The implementations of buy() and sell () require the use of basic mechanisms introduced in Section 4.4, so we defer them to that section. Beyond thesebasic methods, an actual application of these ideas would likely use a number ofother clients. For example, a broker might want to build an array of all accounts,then process a list of transactions that both modify the information in those accounts and actually carry out the transactions through the web. Of course, suchcode needs to be developed with great care!


iiikSiiSSii^^ \

m

ii

Program 3.2.8 Stock account

public class StockAccount{

private final String name;private double cash;private int N;private int[] shares;private String[] stocks;

public StockAccount(In in){ // Build data structure from input stream,

name = in.readl_ine();cash = in.readDouble();N = in.readlntO;shares = new int[N];stocks = new String[N];for (int i = 0; i < N; i++){ // Process one stock.

shares [i] = in.readlntO;stocks[i] = in.readStringO ;

}

}}

public void printReport(){ /* See text. */ }


In in = new In(args[0]);StockAccount acct = new StockAccount(in);acct.pri ntReport();

}

name customer name

cash cash balance

N number ofstock

shares [] share counts

stocks [] stock symbols

in input stream

This class for processing stock accounts illustrates typical usage of object-oriented programmingforcommercial dataprocessing.

% more Turing.txtTuring, Alan10.24

5

100 ADBE

25 G00G

97 IBM

250 MSFT

200 YH00

IW^SfP

rf-™*- .^e„*i- xA~*~b.,w.*,.**....™**J1**,^i^™^•;",".• '>,'..',

java StockAccount Turing.txtTuring, Alan

100

25

97

250

200

ADBE

G00G

IBM

MSFT

YH00

Cash: $ 10.24

$ 42.23$473.25

$104.40$ 30.25$ 28.39

Total:

$ 4222.91$ 11831.25$ 10126.80

$ 7562.50$ 5678.00$ 39431.70

I

S!^^^^^^^^^^^^^fe^^S^^RfflS^W^^fe^^^fe^^?^fw^


When you learned how to define functions that can be used in multiple places ina program (or in other programs) in Chapter 2, you moved from a world whereprograms are simply lists of statements in a single fileto the world of modular programming, summarized in our mantra: whenever you canclearly separate subtaskswithin aprogram, youshould doso.The analogouscapabilityfor data, introduced inthis chapter, moves you from a worldwheredata has to be one of a fewelementarytypes of data to a world whereyou can define your own types of data. This profound new capabilityvastly extends the scope of your programming. Aswith theconceptof a function, onceyou havelearnedto implement and use data types,youwill marvel at the primitive nature of programs that do not use them.

But object-oriented programming is much more than structuring data. It enablesus to associatethe data relevantto a subtask with the operations that manipulate that data and to keep both separate in an independent module. With object-oriented programming, our mantra is this: whenever you can clearly separate dataandassociated operationsforsubtasks within a computation, youshould doso.

The examples that we have considered are persuasive evidence that object-oriented programming can playa usefulrole in a broad range of activities. Whetherwe are trying to design and build a physical artifact, develop a software system,understand the natural world,or process information, a key first step is to definean appropriate abstraction, such as a geometric description of the physical artifact,a modular designof the software system, a mathematical model of the naturalworld, or a data structure for the information. When wewant to write programs tomanipulate instances of a well-defined abstraction, we can just implement it as adata type in a Java class and write Java programs to createand manipulate objectsof that type.

Each time that we develop a class that makes use of other classes by creatingand manipulating objectsof the type definedby the class, weare programming at ahigher layerof abstraction. In the next section,we discuss some of the designchallengesinherent in this kind of programming.


Q. Do instance variables have initial values that we can depend upon?

A Yes. They are automatically set to 0 for numeric types, f al se for the bool eantype, and the special value null for all reference types. These values are consistentwith the wayarray entries are initialized. This automatic initialization ensures thatevery instance variable always stores a legal (but not necessarily meaningful) value.Writing code that depends on these values is controversial: some experienced programmers embrace the idea because the resulting code can be very compact; othersavoid it because the code is opaque to someone who does not know the rules.

Q. What is null?

A It is a literal value that refers to no object. Invoking a method using the nullreference is meaningless and results in a NullPointerException. If you get thiserror message, check to make sure that your constructor properly initializes all ofits instance variables.

Q. Can we initialize instance variables to other valueswhen declaring them?

A. Yes, you can initialize instance variables using the same conventions as you havebeen using for initializing local variables. Each time a client creates an object withnew, Java initializes its instance variables with those values, and then calls the constructor.

Q. Must every classhave a constructor?

A. Yes, but if you do not specify a constructor, Java provides a default (no-argument) constructor automatically. When the client invokes that constructor withnew, the instance variables are auto-initialized as usual. If you dospecify a constructor, the default no-argument constructor disappears.

Q. Suppose I do not include a toStri ng() method. What happens if I try to printan object of that type with StdOut. pri ntl n() ?

A. The printed output is an integer that is unlikelyto be of much use to you.

Q. Can I have a static method in a class that implements a data type?


A. Of course. For example, all of our classes have mai n() . But it is easy to getconfused when static methods and instance methods are mixed up in the samecode.For example, it is natural to considerusingstatic methods for operations thatinvolve multiple objects where none of them naturally suggests itself as the onethat should invoke the method. For example, we sayz. abs () to get \z\, but sayinga. pi us (b) to get the sum is perhaps not so natural. Why not b. pi us (a) ?An alternative is to define a static method like the following within Compl ex:

public static Complex pi us(Complex a, Complex b){

return new Complex(a.re + b.re, a.im + b.im);}

We generallyavoid such usage and livewith expressions that do not mix static andinstance methods to avoid having to write code like this:

z = Complex.pi us(Complex.times(z, z), zO)

Instead, we would write:

z = z.times(z).plus(zO)

Q. These computations with plus() and times() seem rather clumsy. Is theresome way to use symbols like + and * in expressions involving objects where theymake sense,like Compl ex and Vector, so that we could write expressionslike z =z * z + zO instead?

A. Some languages (notably C++) support this feature, which is knownas operator overloading, but Java does not do so (except that there is language support for overloading + with string concatenation). As usual, thisis a decision of the language designers that we just live with, but manyJavaprogrammers do not consider this to be much of a loss. Operator overloadingmakessenseonly for types that representnumeric or algebraicabstractions, a smallfraction of the total, and many programs are easierto understand when operationshave descriptive names such as pi us and times. The APL programming languageof the 1970s took this issue to the opposite extreme by insisting that every operation be represented by a singlesymbol (including Greek letters).


Q. Are there other kinds of variables besides argument, local, and instance variables in a class?

A If you include the keyword stati c in a variable declaration (outside of anymethod), it creates a completely different type of variable, known as a static variable or class variable. Like instance variables, static variables areaccessible to everymethod in the class; however, theyarenot associated with anyobject—there is onevariable per class. In older programming languages, such variables are known asglobal variables because of their global scope. In modernprogramming, we focuson limiting scopeand therefore rarelyuse such variables.

Q. Mandelbrot creates hundreds of millions of Complex objects. Doesn't all thatobject-creationoverheadslowthings down?

A. Yes, but not somuch thatwe cannot generate ourplots. Ourgoal isto make ourprograms readable and easy to maintain—limiting scope via the complex numberabstraction helps usachieve thatgoal. You certainly could speed up Mandel brot bybypassing the complex numberabstraction or byusing a different implementationof Complex. We will revisit this issue in the next section.

405


3.2.1 Consider the following data-type implementation for (axis-aligned) rectangles, which represents each rectangle withthe coordinates of itscenter pointandits width and height:

public class Rectangle{

private final double xprivate final double y;

private final double widthprivate final double height;

public Rectangle(double xO, double yO, double w, double h){

x = xO;

y = yO;width = w;height = h;

}public double area(){ return width * height; }

}

public double perimeter(){ /* Compute perimeter. */ }

public boolean intersects(Rectangle b){ /* Does this rectangle intersect b? */ }

public boolean contains(Rectangle b){ /* Is b inside this rectangle? */ }

public void show(Rectangle b){ /* Draw rectangle on StdDraw. */ }

representation

height(x,y)

width

a

b

m

Write an API for this class, and fill in the code for perimeter(), intersects(),and contai ns(). Note:Treat coincident lines as intersecting, so that, for example,a. intersects (a) is true and a. contains (a) is false.

3.2.2 Write a test client for Rectangl e that takes three command-line argumentsN, mi n, and max; generates Nrandom rectangles whose width and height are uni-


formly distributed between mi n and max in the unit square; draws them on StdDraw; and prints their average area and average perimeter to standard output.

3.2.3 Add code to your test client from the previous exercise code to computethe average number of pairs of rectangles that intersect and are contained in oneanother.

3.2.4 Develop an implementation of your Rectangle API from Exercise 3.2.1that represents rectangles with the coordinates of their lowerleft and upper rightcorners. Do notchange the API.

3.2.5 What is wrong with the following code?


private double rx, ry; // positionprivate double q; // charge

public Charge(double xO, double yO, double qO){

double rx = xO;double ry = yO;double q = qO;

}

}

Answer. The assignment statements in the constructor are also declarations thatcreate new local variables rx, ry, and q, which are assigned values from the arguments but are never used. The instance variables rx, ry, and q remain at their default value of 0. Note: A local variable with the same name as an instance variable is

said to shadow the instance variable—we discuss in the next section a way to referto shadowedinstancevariables, whichare best avoided by beginners.

3.2.6 Create a data type Locati on that representsa location on Earth using latitudes and longitudes. Include a method distanceToO that computes distancesusing the great-circle distance (see Exercise1.2.33).

407


3.2.7 Implement a datatype Rational for rational numbers that supports addition, subtraction, multiplication, and division.

public class Rational

Rational(int numerator, int denominator)

Rational plus(Rational b) sum ofthis number and b

Rational minus (Rati onal b) difference ofthisnumber and b

Rational times (Rati onal b) product ofthisnumber and b

Rati onal over (Rati onal b) quotient of this number andb

St ri ng toSt ri ng() string representation

Use Eucl i d. gcd() (Program 2.3.1) to ensure that the numerator and denominator never have anycommon factors. Include a test client that exercises all of yourmethods. Do not worryabout testing for overflow (see Exercise 3.3.24).

3.2.8 Writea data type Inte rval that implements the following API:

public class Interval

Interval(double left, double right)

bool ean contai ns (doubl e x) isx in this interval?

boolean intersects(Interval b) does this interval and b intersect?

String toStri ng() string representation

An intervalis definedto be the set of allpoints on the line greaterthan or equal to1eft and less than or equalto ri ght. In particular, an intervalwith ri ght less than1eft is empty. Write a client that is a filter that takes a double value x from thecommandline and prints allof the intervals on standardinput (each defined by apair of doubl e values) that contain x.

3.2.9 Writea clientfor your Inte rval class from the previousexercise that takesan i nt value N as command-line argument, reads N intervals (each defined by a


pair of doubl e values) from standard input, and prints all pairs that intersect.

3.2.10 Develop an implementation of your Rectangle API from Exercise 3.2.1that takes advantageof Interval to simplify and clarifythe code.

3.2.11 Write a data type Point that implements the following API:

public class Point

Point (double x, double y)

doubl e di stanceTo (Poi nt q) Euclidean distance between this pointandq

Stri ng toStri ng () string representation

3.2.12 Add methods to Stopwatch that allowclientsto stop and restart the stopwatch.

3.2.13 Use a Stopwatch to compare the cost of computing Harmonic numberswith a for loop (seeProgram 1.3.5) asopposed to usingthe recursive method givenin Section 2.3.

3.2.14 Develop a version of Hi stogram that uses Draw, so that a client can createmultiplehistograms. Addto the display a redvertical lineshowing the samplemeanand blue vertical lines at a distance of two standard deviations from the mean. Use a

test client that createshistograms for flippingcoins (Bernoulli trials) with a biasedcoin that is headswith probabilityp, forp = .2, .4, .6.and .8, takingthe number offlips and the number of trials from the command line, as in Program 3.2.3.

3.2.15 Modifythe test client in Tu rtl e to produce stars with Npoints for odd N.

3.2.16 Modify the toString() method in Complex (Program 3.2.2) so that itprints complex numbers in the traditional format. For example, it should print thevalue3-ias3 - i instead of 3.0 + -1.0i,thevalue3as3insteadof 3.0 + O.Oi,and the value 3i as 3i instead of 0.0 + 3. Oi.

409


3.2.17 Write a Complex client that takes three double values a, b, and c as command-linearguments and prints out the complex roots ofax2 + bx + c.

3.2.18 Write a Compl ex client Roots that takes two doubl e values a and band aninteger N from the command line and prints the Nth roots of a + hi.Note: skipthis exercise if you are not familiar with the operationof takingroots of complexnumbers.

3.2.19 Implement the following additions to the Compl ex API:

double thetaO

Complex minus(Complex b)

Complex conj ugate()

Complex divides(Complex b)

Complex power (int b)

phase (angle) of this number

difference of this number and b

conjugate of thisnumber

result ofdividing this number byb

result of raising thisnumber to thebthpower

Write a test client that exercises all of your methods.

3.2.20 Suppose you want to add a constructor to Complex that takes a doublevalue as argument and creates a Compl ex numberwith that value as the realpart(and no imaginarypart). You write the following code:

public void Complex(double real){

re = real;im = 0.0;

}

But then Compl ex c = new Compl ex(1.0) does not compile. Why?

Answer. Constructors do not have return types, not even voi d. The code abovedefines a method named Compl ex, not a constructor. Remove the keyword voi d.

3.2.21 Find a Compl ex value for which mand () returns a number greater than 100,and then zoom in on that value, as in the example in the text.

3.2.22 Implementthe write() method for StockAccount (Program3.2.8).


3.2.23 Mutable charges. ModifyCharge so that the chargeq isnot final, andadd a method i ncreaseChargeO that takes a double argument and adds thegivenvalue to the charge.Then, write a client that initializes an array with:

Charged a = new Charge[3];a[0] = new Charge(.4, .6, 50)a[l] = new Charge(.5, .5, -5)a[2] = new Charge(.6, .6, 50)

and then displays the result of slowlydecreasing the charge value of a[i ] bywrapping the code that computes the picture in a loop like the following:

for (int t = 0; t < 100; t++){

// compute the picturepic.showO;a[l].change(-2);

}

3.2.24 Complex timing. Write a Stopwatch client that compares the cost ofusing Complex to the cost of writing code that directlymanipulates two doubl e values, for the task of doing the calculations in Mandel brot. Specifically,create a version of Mandel brot that just does the calculations (remove the codethat refersto Pictu re), then createa versionof that program that does not useCompl ex, and then compute the ratio of the running times.

3.2.25 Quaternions. In 1843, Sir William Hamilton discovered an extensionto complex numbers called quaternions. Aquaternion isa vectora = (a0, ax, a2,a3) with the following operations:

•Magnitude: \a\ = yja02 + ax2 + a22 + a32.• Conjugate: the conjugateof a is (a0, —av —a2, —a3).• Inverse: arx = (a0/\a\, —ax/\a\, -a2/\a\, -a3/\a\).• Sum: a+b = (a0+ b0,ax + bx,a2 + b2,a3 + b3).• Product a*b= (a0bQ —axbx —a2b2 —a3b3,aQbx —albQ-\- a2b3 —a3b2,

a0 b2 —axb3+ a2 bQ + a3 bx, a0 b3 + ax b2 —a2 bx + a3 b0).• Quotient alb =ab~l.

411

ItL

-105

-155

-205

Mutating a charge


Create a data type for quaternionsand a test client that exercises all of your code.Quaternions extend the concept of rotation in three dimensions to four dimensions. They are used in computer graphics, control theory, signalprocessing, andorbital mechanics.

3.2.26 Dragon curves. Write a recursive Turtl e client Dragon that draws dragoncurves (see Exercises 1.2.35 and 1.5.9).

% java Dragon 15

Answer: These curves, originally discovered by threeNASA physicists, were popularized in the 1960s byMartin Gardner and later used by MichaelCrichton inthe book and movie JurassicPark. This exercise can besolvedwith remarkably compact code, based on a pairof mutually interacting recursive functions deriveddirectly from the definition in Exercise 1.2.35. One ofthem, dragon (), should draw the curve as you expect;the other, nogardO, should draw the curve in reverseorder. See the booksite for details.

3.2.27 Hilbert curves. Aspace-filling curveisacontinuous curvein the unit squarethat passes throughevery point.Write a recursive Tu rtl e clientthat produces theserecursive patterns, which approach a space-filling curve that was defined by themathematician David Hilbert at the end of the 19th century.

zi c

Partial answer Seethe previous exercise. You need a pair of methods: hi 1bert (),which traverses a Hilbert curve, and treblih(), which traverses a Hilbert curve inreverse order. See the booksite for details.


3.2.28 Gosper island. Write a recursive Turtle client that produces these recursive patterns.

3.2.29 Data analysis. Write a data type for use in running experiments where thecontrol variable is an integer in the range [0, N) and the dependent variable is adouble value. (For example,studying the running time of a program that takes aninteger argument would involve such experiments.) Implement the following API.

public class Data

Data(int N, int max)create a newdata analysisobjectfor theN int valuesin [0, N)

double addDataPoint (int i, double x) add a data point (i, x)

voi d pi ot () plot allthe data points

void TukeyPlotO draw a Tukey plot (see Exercise 2.2.18)

You can use the static methods in StdStats to do the statistical calculations and

draw the plots. Use StdDraw so clients can use different colors for plot() andTukeyPlotO (for example, light gray for all the points and black for the Tukeyplot). Write a test client that plots the results (percolation probability) of runningexperiments with Percol ati on as the grid size increases.

3.2.30 Elements. Create a data type Element for entries in the Periodic Table ofElements. Include data type valuesfor element,atomicnumber, symbol,and atomicweight and accessor methods for each of these values. Then, create a data type

413


Peri odi cTabl e that reads values from a file to create an array of Element objects(you can find the file and a description of its format on the booksite) and respondsto queries on standard input so that a user can type a molecular equation likeH20 and the program responds by printing the molecular weight.DevelopAPIsandimplementations for each data type.

3.2.31 Stock prices. The file DJIA.txt on the booksite contains all closing stockprices in the history of the Dow JonesIndustrial Average, in the comma-separated-value format. Create a data type Entry that can hold one entry in the table, withvalues for date, opening price, daily high, daily low, closing price, and so forth.Then, create a data type Table that reads the file to build an array of Entry objectsand supports methods for computing averages overvarious periods of time. Finally,create interestingTabl e clientsto produce plots of the data. Becreative: this path iswell-trodden.

3.2.32 Chaos with Newton's method. The polynomial/(z) = z4 - 1has four roots:at 1, —1, i, and —i. We can find the roots using Newton's method in the complexplane:zk+x = zk- f(zk)/f(zk). Here,/(z) = z4 - 1 and/l(z) = 4z3. The method convergesto one of the four roots, depending on the starting point z0. Write a Compl exclient Newton that takes a command-line argument N and colors pixels in an N-by-N Pictu re white,red,green,or blue by mapping the pixels complexpoints in aregularly spacedgrid in the squareof size 2 centeredat the origin and coloringeachpixel according to which of the four roots the corresponding point converges (black if no convergenceafter 100 iterations).

3.2.33 Equipotential surfaces. An equipotential surface is the set of all points that have the same electricpotential V. Given a group of point charges, it is usefulto visualize the electric potential by plotting equipotential surfaces (also known as a contour plot). Writea program Equipotenti al that draws a line every 5Vby computing the potential at each pixel and checking whether the potential at the corresponding point

if (g != 255) 17 % 256;


is within 1 pixel of a multiple of 5V. Note: A very easy approximate solution to thisexercise is obtained from Program 3.1.7 by scrambling the color values assignedto each pixel, rather than having them be proportional to the grayscalevalue. Forexample, the accompanying figure is created by inserting the code above it beforecreating the Color. Explain why it works, and experiment with your own version.

3.2.34 Color Mandelbrotplot. Create a fileof 256 integer triples that represent interesting Color values, and then use those colors instead of grayscalevalues to ploteach pixel in Mandel brot: Read the values to create an array of 256 Color values,then index into that array with the return value of mand (). Byexperimenting withvarious color choicesat various places in the set,you can produce astonishing images.See mandel. txt on the booksite for an example.

3.2.35 Julia sets. The Julia set for a given complex number c is a set of pointsrelated to the Mandelbrot function. Instead of fixing z and varying c,we fix c andvary z. Those points z for which the modified Mandelbrot function stays boundedare in the Julia set, those for which the sequence diverges to infinity are not in theset.Allpoints z of interest lie in the 4-by-4box centered at the origin. The Julia setfor c is connected if and only if c is in the Mandelbrot set! Write a program Color-Jul i a that takes two command line arguments a and b,and plots a color version ofthe Julia set for c = a + bi,using the color-table method described in the previousexercise.

3.2.36 Biggest winner and biggest loser. Write a StockAccount client that buildsan array of StockAccount objects, computes the total value of each account, andprints a report for the accounts with the largest value and the account with thesmallest value.Assume that the information in the accounts are kept in a single filethat contains the information for the accounts, one after the other, in the formatgiven in the text.


3.3 Designing Data Types

The ability to create data types turns every programmer into a language designer.You do not have to settle for the types of data and associated operations that arebuilt into the language, because you caneasily create your own types of data and.1 .. i. . .-, . ,i 3.3.1 Complex numbers (alternate) . . .421then write client programs that use them. .. „ _ \ „„_

r ° 3.3.2 Counter 425Java does not have complex numbers 333 spatial vectors 432built in, but you can define Compl ex and 3.3,4 Document .441writeprograms suchas Mandel brot. Java 3.3.5 Similarity detection . .444doesnot have a built-in facility for turtle Programs in this sectiongraphics, but you can define Turtl e andwrite client programs that take immediate advantage of this abstraction. Evenwhen Javadoes have a particular facility, wecan use a data type to tailor it to our needs,aswe do when we use our Std* librariesinstead the more extensive ones provided by Javafor software developers.

Now, the first thing that we strive for when creating a program is an understanding of the types of data that wewillneed. Developingthis understanding is adesign activity. In this section,we focus on developing APIsas a critical step in thedevelopment of any program. Weneed to consider various alternatives,understandtheir impact on both client programs and implementations, and refine the designto strike an appropriate balance between the needs of clients and the possible implementation strategies.

If you take a course in systemsprogramming, you will learn that this designactivity is critical when building large systems,and that Javaand similar languageshave powerful high-level mechanisms that support code reuse when writing largeprograms. Many of these mechanismsare intended for use by experts building largesystems, but the general approach is worthwhile for every programmer, and someof these mechanisms are useful when writing small programs.

In this section we discuss encapsulation, immutability, and inheritance, withparticular attention to the use of these mechanisms in data-type design to enablemodular programming, facilitate debugging, and write clear and correct code.

At the end of the section, we discuss Java's mechanisms for use in checkingdesign assumptions against actual conditions at runtime. Such tools are invaluableaids in developing reliable software.


DesigningAPIs* In Section 3.1, wewrote client programs that use APIs; in Section 3.2, we implemented APIs. Now we consider the challenge of designing APIs.Treating these topics in this order and with this focus is appropriate because mostof the time that you spend programmingwillbe writing clientprograms.

Often the most important and most challengingsteps in building software isdesigning the APIs.This task takes practice,careful deliberation, and many iterations.However, any time spent designing a goodAPI is certain to be repaid in time savedduring debugging or with code reuse.

Articulating an API might seem tobe overkill when writing a small program,but you should consider writing everyprogram as though you will need to reuse thecode someday—not because you knowthat you will reuse that code, but becauseyou are quite likely to want to reuse someof your code and you cannot know whichcode you will need.

client

API

creates objectsand invokes methods

public class Charge

417


double potential At(double x, double y) due^o chargestring

representation

Standards. It is easy to understand whywriting to an API is so important by considering other domains. From railroadtracks, to threaded nuts and bolts, to fax

machines, to radio frequenciesstandards, we know that using astandard interface enables the broadest us

age of a technology. Java itself is anotherexample: your Java programs are clients ofthe Java virtual machine, which is a stan

dard interface that is implemented on awide variety of hardware and softwareplatforms. By using APIs to separate clients from implementations, we reap thebenefits of standard interfaces for everyprogram that we write.

String toStringQ

implementation

defines signaturesand describes methods

\kM public Charge(double xO, double yO, double qO)lit ••• >

BFPSWfl-W "W* XWr-J*.

[f;M public double potentialAt(double x, double y)W3 J }

definesinstance variablesand implements methods

Object-oriented library abstraction


Specification problem. Our APIs are lists of methods, along with brief English-language descriptions of what the methods are supposed to do. Ideally, an APIwould clearlyarticulate behavior for all possible inputs, including side effects, andthen we would have software to check that implementations meet the specification.Unfortunately, a fundamental result from theoretical computer science, known asthe specification problem, saysthat this goal is actually impossible to achieve.Briefly,such a specification would have to be written in a formal language like a programming language, and the problem of determining whether two programs performthe same computation is known, mathematically, to be unsolvable. (If you are interested in this idea, you can learn much more about the nature of unsolvable problems and their role in our understanding of the nature of computation in a coursein theoretical computer science.)Therefore,we resort to informal descriptions withexamples, such as those in the text surrounding our APIs.

Wide interfaces. A wide interface isone that hasan excessive number of methods.An important principle to follow in designing an API is to avoid wide interfaces.The sizeof an API naturally tends to growover time because it is easyto add methods to an existingAPI,whereas it is difficult to remove methods without breakingexisting clients. In certain situations, wide interfaces are justified—for example, inwidely used systems libraries such as St ri ng.Various techniques are helpful in reducing the effective width of an interface. For example, we considered in Chapter 2several libraries that use overloading to provide implementations of basic methodsfor all types of data. Another approach is to include methods that are orthogonal infunctionality. For example, Java's Math library includes methods for si n(), cos(),and tan (), but not sec ().

Start with client code. One of the primary purposes of developing a data typeis to simplify client code. Therefore, it makes sense to pay attention to client codeform the start when designing an API. Very often, doing so is no problem at all,because a typical reason to develop a data type in the first place is to simplify clientcode that is becoming cumbersome. When you find yourself with some client codethat you are not proud of, one way to proceed is to write a fanciful simplified version of the code that expressesthe computation the way you are thinking about it,at some higher level that does not involvethe details of the code. If you have done agood job of writing succinct comments to describe your computation, one possiblestarting point is to think about opportunities to convert the comments into code.

3.3 Designing Data Types 419

Remember the basic mantra for data types: whenever you can clearly separate dataand associated operations within a program, you should do so. Whatever the source,it is normally wise to write client code (and develop the API) before working on animplementation. Writing two clients is evenbetter. Starting with client code is oneway of ensuring that developing an implementation willbe worth the effort.

Avoid dependence on representation. Usually whendeveloping an API, we havea representation in mind. After all, a data type is a set of values and a set of operations on those values, and it does not make much sense to talk about the operationswithout knowing the values. But that is different from knowing the representationof the values. One purpose of the data type is to simplify client code by allowing itto avoid details of and dependence on a particular representation. For example, ourclient programs for Pi ctu re and StdAudi o work with simple abstract representations of pictures and sound, respectively. The primary value of the APIs for theseabstraction is that they allow client code to ignore a substantial amount of detailthat is found in the standard representations of those abstractions.

Pitfalls in API design. An API may be too hard to implement, implying implementations that are difficult or impossible to develop; or too hard to use, creatingclient code that is more complicated than without the API. An API might be toonarrow, omitting methods that clients need; or too wide, including a large numberof methods not needed by any client.An API may be too general, providing no use-fill abstractions; or too specific, providing abstractions so detailed or so diffuse as tobe useless.These considerations are sometimes summarized in yet another motto:provide to clients themethods theyneed and no others.

When you first started programming, you typed in He!1oWor1d. j ava without understanding much about it except the effect that it produced. From that startingpoint, you learned to program by mimicking the code in the book and eventuallydeveloping your own code to solve various problems. You are at a similar pointwith API design. There are many APIs available in the book, on the booksite, andin online Java documentation that you can study and use, to gain confidence indesigning and developing APIs of your own.


Encapsulation. The process of separating clients from implementations byhiding information is known as encapsulation. Details of the implementation arekept hidden from clients, and implementations have no way of knowing details ofclient code, which may even be created in the future.

Asyou may havesurmised,wehavebeen practicing encapsulation in our datatype implementations. In Section 3.1,westarted with the mantra youdonotneed toknow howa datatype is implemented in order to useit.This statement describes oneof the prime benefits of encapsulation. We consider it to be so important that wehave not described to you any other wayof building a data type. Now,we describeour three primary reasons for doing so in more detail. We use encapsulation:

• To enable modular programming• Tofacilitate debugging• To clarify program code

These reasons are tied together (well-designed modular code is easier to debug andunderstand than code based entirely on primitive types in long programs).

Modular programming. The programming style that we have been developingsince learning functions in Chapter 2 has been predicated on the idea of breaking large programs into small modules that can be developed and debugged independently. This approach improves the resiliency of our software by limiting andlocalizing the effects of making changes,and it promotes code reuse by making itpossible to substitute new implementations of a data type to improve performance,accuracy, or memory footprint. The same idea works in many settings. We oftenreap the benefits of encapsulation when we use system libraries. New versions ofthe Javasystem often include new implementations of various data types or staticmethod libraries, but the APIs do notchange. There is strong and constant motivation to improvedata-type implementationsbecauseallclientscan potentiallybenefit from an improved implementation. The key to success in modular programming is to maintain independence among modules. Wedo so by insisting on the APIbeing the onlypoint of dependence between client and implementation. You do notneed to know howa data type is implemented in order to use it. The flip side of thismantra is that a data-type implementation code can assume that the client knowsnothing but the API.

Example. For example, consider Compl ex (Program 3.3.1). It has the same nameand API as Program 3.2.6,but usesa different representation for the complex num-


II

111

Program33A Complexnumbers (alternate)

public class Complex{

private final double r;private final double theta;

public Complex(double re, double im){

r = Math.sqrt(re*re + im*im);theta = Math.atan2(im, re);

}

public Complex pi us(Complex b){ // Return the sum of this number and b.

double real = re() + b.re();double imag = im() + b.im();return new Complex(real, imag);

}

public Complex times(Complex b){ // Return the product of this number and b.

double radius = r * b.r;double angle = theta + b.theta;// See Q & A.

Polar represen tation

}

public double abs(){ return r; }

public double re()public double im()

public String toString(){ return re() + " + " + im() + "i"; }

public static void main (Stri ng[] args){

Complex zO = new Complex(1.0, 1.0);Complex z = zO;z = z.times(z).plus(zO);z = z.times(z).plus(zO);StdOut.println(z);

{ return r * Math.cos(theta); }{ return r * Math.sin(theta); }

This data type implements the same APIasProgram 3.2.5. It uses the same instance methodsbutdifferent instance variables. Since the instance variables are private, this program mightbeused in placeofProgram 3.2.5 without changing anyclientcode.

-7.0 + 7.0i

sSpJOTsSS'*


bers. Program 3.2.6 uses the Cartesian representation, where instance variables xand y represent a complex number x + iy. Program 3.3.1 uses the polarrepresentation, where instance variables r and theta represent a complex number in theform r(cos 0 + isin 0). The polar representationis of interest because certain operations on complex number are easier to perform in the polarrepresentation. Addition and subtraction are easier in the Cartesian representation; multiplication and division are easier in thepolar representation. Asyou willlearn in Section 4.1, it is often thecase that performancedifferences aredramatic.The idea of encapsulation is that we can substitute one of these programs for theother (for whatever reason) without changing client code. Thechoicebetweenthe two implementationsdepends on the client. Indeed, in principle, the only difference to the client should be in different performance properties.This capability is of criticalimportance for many reasons. One of the most important is that it allows us to improve software constantly:when we develop a betterwayto implement a data type, all of its clients can benefit. You take advantage ofthis property every time you install a newversion of a software system, includingJava itself.

Private. Java's language support for enforcing encapsulation is the private visibilitymodifier. When you declare a variable to be pri vate, you are making it impossible for any client (code in another module) to directly access the instancevariable (or method) that is the subjectof the modifier. Clients can only access theAPI through the public methods and constructors (the API). Accordingly, youcan modify the implementation of private methods (or use different privateinstance variables) with certain knowledge that no client will be directlyaffected.Java does not require that all instance variables be private, but we insist on thisconvention in the programs in this book. For example, if the instance variable reand i min Compl ex (Program 3.2.6) were publ i c, then a client could write code thatdirectly accesses them. If z refersto a Compl ex object, z. re and z. i mrefer to thosevalues. But any client code that does so becomes completely dependent on thatimplementation, violatinga basicprecept of encapsulation.A switch to a differentimplementation, such as the one in Program 3.3.1, would render that code useless. Toprotect ourselves againstsuch situations,we always make instance variablesprivate; there is no good reason to make them public. Next, we examine someramifications of this convention.


Planning for thefuture. Therehave been numerous examples of important applications where significant expense can be directly traced to programmers notencapsulating their data types.

• Zip codes. In 1963,The United States Postal Service (USPS) began using afive-digit zip code to improve the sorting and deliveryof mail. Programmers wrote software that assumed that these codes would remain at five

digits forever, and represented them in their programs using a single 32-bitinteger. In 1983, the USPSintroduced an expanded zip code called ZIP+4,which consists of the original five-digit zip code plus four extra digits.

• IPv4vs. IPv6. The Internet Protocol (IP) is a standard used by electronicdevices to exchange data over the internet. Eachdeviceis assigneda uniqueinteger or address. IPv4 uses 32-bit addresses and supports about 4.3billion addresses. Due to explosive growth of the internet, a new version,IPv6, uses 128-bit addresses and supports 2128 addresses.

• Vehicle identification numbers. The 17-character naming schemefor vehicles known as the Vehicle Identification Number (VIN) that was established in 1981 describes the make, model, year,and other attributes ofcars, trucks, buses, and other vehicles in the United States. But automakers

expect to run out of numbers by 2010. Either the length of the VIN mustbe increased, or existingVINs must be reused.

In each of these cases,a necessarychange to the internal representation means thata large amount of client code that depends on a current standard (because the datatype is not encapsulated) will simply not function as intended. The estimated costsfor the changes in each of these casesruns to hundreds of millions of dollars! Thatis a huge cost for failing to encapsulate a single number. These predicaments mightseem distant to you, but you can be sure that every individual programmer (that'syou) who does not take advantage of the protection available through encapsulation risks losing significant amounts of time and effort fixing broken code whenconventions change. Our convention to define allof our instance variables with theprivate access modifier provides some protection against such problems. If youadopt this convention when implementing a data type for a zip code, IP address,VIN, or whatever,you can change the representation without affecting clients. Thedata-type implementation knows the data representation, and the object holds thedata; the clientholds only a reference to the object and does not know the details.


Limiting the potential for error. Encapsulation also helps programmers ensurethat their code operates as intended. As an example, we consider yet another horror story: In the 2000 presidential election,Al Gore received negative 16,022voteson an electronic voting machine in Volusia County, Florida. The counter variablewas not properly encapsulated in the voting machine software! To understand theproblem, consider Counter (Program 3.3.2),which implements a simple counteraccording to the followingAPI:

public class Counter

Counter (Stri ng id, i nt max) create a counter, initialized to 0

voi d i ncrement () increment the counter unless itsvalue ismax

i nt val ue () return the value of the counter


APIfor a counter (seeProgram 3.3.2)

This abstraction is useful in many contexts, including, for example, an electronicvoting machine. It encapsulates a singleinteger and ensures that the only operationthat can be performed on the integer is increment byone. Therefore, it can never gonegative. The goalof data abstraction is to restrictthe operations on the data. It alsoisolates operations on the data. For example,we could add a new implementationwith a logging capability so that i ncrement () saves a timestamp for each vote orsome other information that can be used for consistency checks. But without theprivate modifier, there could be client code like the following somewhere in thevoting machine:

Counter c = new Counter("Volusia", VOTERS_IN_VOLUSIA_COUNTY);c.count = -16022;

With private, code like this will not compile; without it, Gore's vote count wasnegative.Using encapsulation is far from a complete solution to the voting securityproblem, but it is a good start.

Code clarity. Precisely specifying a data type is good design also because it leadsto client code that can more clearly express its computation. You have seen manyexamples of such client code in Sections 3.1 and 3.2,and we already mentioned thisissue in our discussion of Hi stogram (Program 3.2.3). Clients of that program are


Hi

Wm

m

Program 33.2 Counter


{private final String name;private final int maxCount;private int count;

public Counter(String id, int max){ name = id; maxCount = max; }

public void increment(){ if (count < maxCount) count++; }

public int value(){ return count; }

public String toString(){ return name + ": " + count; }

public static void main(String[] args){int N = Integer.parselnt(args[0]);int T = Integer.parselnt(args[1]);Counter[] hits = new Counter[N];for (int i = 0; i < N; i++)

hits[i] = new Counter(i + "", T);

for (int t = 0; t < T; t++)hits[StdRandom.uni form(N)].i ncrement();

for (int i = 0; i < N; i++)StdOut.pri ntln(hits[i]);

name

maxCount

count

counter name

maximum value

value

This class encapsulates a simple integer counter, assigning it a string name and initializingit to 0 (Java's default initialization), incrementing it each time the client calls i ncrement(),reporting the value when the client calls value(), and creating a suing with its name andvalue in toStri ng().

%java Counter 6 600000 |f0: 100684

1: 99258

2: 100119

3: 100054

4: 99844

5: 100037

^5^w5^ffi^^^^S^wWSi^ER^^w

|I-


more clear than without it because calls on the instance method addDataPoi nt ()

clearlyidentify points of interest in the client. One key to good design is to observethat code written with the proper abstractions can be nearly self-documenting.Some aficionados of object-oriented programming might argue that Histogramitself would be easier to understand if it were to use Counter (see Exercise 3.3.5),but that point is perhaps debatable.

We have stressed the benefits of encapsulation throughout this book. We summarize them again here, in the context of designing data types. Encapsulation enablesmodular programming, allowingus to:

• Independently develop of client and implementation code• Substitute improved implementations without affecting clients• Support programs not yet written (any client can write to the API)

Encapsulation also isolates data-type operations, which leads to the possibility of:• Adding consistencychecksand other debugging tools in implementations• Clarifyingclient code

A properly implemented data type (encapsulated) extends the Java language, allowing any client program to make use of it.


Immutability. An immutable data type,such asa Java St ri ng,has the propertythat the value of an object never changesonce constructed. Bycontrast, a mutabledata type, such as a Java array, manipulates object values that are intended tochange. Of the data types considered in this chapter, Charge, Color, Stopwatch,and Compl ex are all immutable, and Pi cture, Histogram, Turtl e, StockAccount,and Counter are all mutable. Whether to make a data type immutable is an important design decision and depends on the application at hand.

Immutable types. The purposeof manydata types isto encapsulate values that donot change so that they behave in the same wayas primitive types. For example, aprogrammer implementing a Compl ex client might reasonably expect to write thecode z = zO for two Compl ex variables, in the same way as for doubl e or i nt values. But if Complex were mutable and the value of z wereto change after the assignment z = zO, then the value ofzO would alsochange (they are both referencesto the sameobject)! This unexpected result, known as an aliasing bug,comes as a surprise to many newcomers to object-orientedprogramming. One very important reason to implementimmutable types is that we can use immutable objects inassignment statements and as arguments and return valuesfrom functions without having to worry about their valueschanging.

Mutable types. For many data types, the verypurpose ofthe abstraction is to encapsulate values as they change. Turtle (Program 3.2.4)is a prime example. Our reason for using Turtle is to relieve client programs ofthe responsibility of tracking the changing values.Similarly, Pi ctu re, Hi stog ram,StockAccount, Counter, and Java arrays are all types where we expect values tochange.When we pass a Turtl e as an argument to a method, as in Koch, we expectthe values of the instance variables to change.

Arrays and strings. You have already encountered this distinctionas a clientprogrammer, when using Java arrays (mutable) and Java's String data type (immutable). When you pass a Stri ng to a method, you do not need to worry about thatmethod changing the sequence of characters in the Stri ng, but when you pass anarray to a method, the method is free to change the elements of the array. Stri ng

427

mutable immutable

Picture Charge

Histogram Color

Turtle Stopwatch

StockAccount Complex

Counter String

Java arrays primitive types


objects are immutable because we generallydo notwant Stri ng values to change,and Java arrays are mutable because we generally do want array values to change.There are also situations where we want to have mutable strings (that is the purpose of Java's Stri ngBui 1der class) and where we want to have immutable arrays(that is the purpose of the Vector class that we consider later in this section).

Advantages of immutability. Generally, immutable typesare easier to use and harder to misuse because the scopeof code that can change their values is far smaller than formutable types. It is easier to debug code that uses immutable types because it is easierto guarantee that variables inthe client code that uses them remain in a consistent state.

When using mutable types, you must always be concernedabout where and when their values change.

Cost of immutability. The downside of immutability isthat a newobject mustbecreatedfor every value. For example, the expression z = z. ti mes (z) .plus (zO) involvescreating a new object (the return value of z.times(z),then using that object to invoke pi us(), but never savinga referenceto it. A program such as Mandel brot (Program3.2.7) might create a large number of such intermediateorphans. However, this expense is normally manageablebecause Java garbage collectors are typically optimized forsuch situations. Also, as in the case of Mandel brot, whenthe point of the calculation is to create a large number ofvalues, we expect to pay the cost of representing them.Mandelbrot also creates a large number of (immutable)Color objects.

Complex zO;zO = new Complex(1.0, 1.0);Complex z = zO;z = z.times(z).plus(zO);

ipSSiilitii

referencezO I 811 1 t^tol +i

z 1 223 1^ referenceto 1 + 3/

223 i i-o 1< 1 + 3/224 * 3,° E

orphaned^/ object

459 i °'° i < 0 + 2;460 i 2,°

811 1 i.o 1< 1'+»"812 1 i.o 1

Ss88!it&V8ftS#!*Ms&&?^

An intermediate orphan

Final. Java's language support for helping to enforce immutability is the f i nalmodifier.When you declare a variable to be f i nal, you are promising to assignit a value only once, either in an initializer or in the constructor. Code that couldmodify the value of a f i nal variable leads to a compile-time error. In our code, wealways use the modifier f i nal with instance variables whose values never change.This policy servesas documentation that the value does not change, prevents acci-


dental changes,and makesprograms easierto debug.For example,you do not haveto include a f i nal value in a trace, sinceyou know that its value never changes.

Reference types. Unfortunately, final guarantees immutability only when instance variables are primitive types, not reference types. If an instance variable ofa reference type has the f i nal modifier, the value of that instance variable (thereference to an object) will never change—it will always refer to the same object.However,the value of the object itself can change. For example, if you have a f i nalinstance variable that is an array,you cannot change the array (to change its length,say), but you can change the individual array elements. Thus, aliasing bugs canarise.For example,this code does notimplement an immutable type:

public class Vector

{private final doubled coords;public Vector(double[] a){

coords = a;}

}

A client program could create a Vector by specifying the entries in an array, andthen (bypassing the API) change the elements of the Vector after construction:

doubled a = { 3.0, 4.0 };Vector vector = new Vector(a);a[0] =17.0; // Bypasses the public API.

The instance variable coords [] is pri vate and f i nal, but Vector is mutable because the client holds the data, not the implementation. To ensure immutability ofa data type that includesan instancevariable of a mutable type,we need to make alocal copy,known as a defensive copy. Next,we consider such an implementation.

Immutability needs to betaken into account in any data-type design. Ideally,whether a data type is immutable should be specifiedin the API,so that clients know thatobject values will not change. Implementing an immutable type can be a burdenin the presence of reference types. For complex types,making the copy is one challenge; ensuring that none of the instance methods change values is another.


Example: spatial vectors To illustrate these ideas in the context of a usefulmathematical abstraction, we now consider a vector data type. Like complex numbers, the basic definition of the vector abstraction is familiar because it has playeda central role in applied mathematics for over 100years. The field of mathematicsknown as linear algebra is concerned with properties of vectors. Linear algebra is arich and successful theory with numerous applications, and plays an importantrole in all fields of social and natural science. Full treatment of linear algebra iscertainly beyond the scope of this book, but several important applications arebased upon elementary and familiar calculations, so we touch upon vectors andlinear algebra throughout the book (for example, the random surfer example inSection 1.6 is based on linear algebra).Accordingly, it is worthwhile to encapsulatesuch an abstraction in a data type.

A spatial vector is an abstract entitythat has a magni- directiontude and a direction. Spatial vectors provide a natural wayto describe properties of the physical world, such as force,velocity, momentum, or acceleration. One standard way tospecify a vector is as an arrow from the origin to a point ina Cartesian coordinate system: the direction is the ray fromthe origin tothe point and the magnitude is the length ofthe Y a spatial vectorarrow (distance from the origin to the point). To specify thevector it suffices to specifythe point.

This concept extends to any number of dimensions: an ordered list of AT realnumbers (the coordinates of an N-dimensional point) suffices to specify a vectorin JV-dimensional space.Byconvention, we use a boldface letter to refer to a vectorand numbers or indexed variable names (the same letter in italics) separated bycommas within square brackets to denote its value. For example, we might use x todenote (x0, xx,..., xN_x) andy to denote (y0,yv...,yN_x).

API. The basicoperationson vectors are to add two vectors, multiplya vectorbya scalar (real number), compute the dot product of two vectors, and compute themagnitude and direction, as follows:

•Addition: x + y = (xq + ^Xj +yp.. .,xN_x +yN_i)• Scalarproduct: tx = (tx0, txv..., txN_x)• Dotproduct: x •y = x^y0 + x^yx + ... + xN_]yN_l• Magnitude: |x| = (x02 + xx2 + ... + xN_l2)m• Direction: x/ |x| = (x0/ |x|,xxl |x|,..., xN_x/ |x|)


The result of addition, scalar product, and the direction are vectors, but the magnitude and the dot product are scalarquantities (double values). For example, ifx = (0, 3,4, 0),and y = (0, -3,1, -4), then x + y = (0,0, 5, -4), 3x = (0, 9,12, 0),x •y = —5, |x| = 5, and x/ |x| = (0, .6, .8,0). The directionvectoris a unitvector: itsmagnitude is 1.These definitions lead immediately to an API:

public class Vector

Vector(double[] a)

Vector pi us(Vector b)

Vector minus(Vector b)

Vector times(double t)

double dot(Vector b)

double magnitude()

Vector directi onO

double cartesian(int i)

String toStringQ

create a vector with thegiven Cartesian coordinates

sum of thisvector and b

difference of thisvector and b

scalar product of thisvector and t

dotproduct of thisvector and b

magnitude of thisvector

unit vector with same direction as this vector

i thcartesian coordinate of thisvector


APIfor a spatialvector {seeProgram 3.3.3)

As with Compl ex, this API does not explicitly specify that this type is immutable,but weknow that client programmers (whoare likely to be thinking in terms of themathematical abstraction) will certainlyexpectthat.

Representation. As usual, our first choice in developing an implementation is tochoose a representation for the data. Using an array to hold the Cartesian coordinates provided in the constructor is a clear choice, but not the only reasonablechoice. Indeed, one of the basic tenets of linear algebra is that other sets of JV vectors can be used as the basis for a coordinate system: any vector can be expressedas a linear combination of a set of N vectors, satisfying a certain condition knownas linear independence. This ability to change coordinate systemsaligns nicelywithencapsulation. Most clients do not need to know about the representation at all andcan work with Vector objects and operations. If warranted, the implementationcan change the coordinate system without affecting client code.

431

432

m


Program333 Spatial vectors

public class Vector{

private final double[] coords; coords[] | Cartesian

public Vector(double[] a){ // Make a defensive copy to ensure immutability.

coords = new double[a.length];for (int i = 0; i < a.length; i++)

coords[i] = a[i];}

public Vector pi us(Vector b){ // Sum of this vector and b.

doubled c = new double[coords. 1ength];for (int i = 0; i < coords.length; i++)

c[i] = coords[i] + b.coords[i];return new Vector(c);

}

public Vector times(double t)

}

{ // Product of this vector and b.doubled c = new double[coords. 1ength];for (int i =0; i < coords.length; i++)

c[i] = t * coords[i];return new Vector(c);

}

public double dot(Vector b){ // Dot product of this vector and b.

double sum =0.0;for (int i = 0; i < coords.length; i++)

sum = sum + (coords[i] * b.coords[i]) ;return sum;

}

public double magnitudeO{ return Math.sqrt(this.dot(this)); }

public Vector direction(){ return this.times(l/this.magnitudeO) ; }

public double cartesian(int i){ return coords[i]; }

coordinates Bmmmw

This implementation encapsulates themathematical spatial-vector abstraction, in an immutable Java data type. Document (Program 3.3.4) and Body (Program 3.4.2) aretypical clients.


Implementation. Given the representation, the code that implements all of these operations (Vector, in Program 3.3.3) isstraightforward. Twoofthe methods (mi nus () and toStri ng())are left for exercises, as is the test client. The constructor makesa defensive copy of the client array and none of the methods assign values to the copy, so that Vector objects are immutable.The cartesi an() method is easyto implement in our Cartesiancoordinate representation: return the ith coordinate in the array.It actually implements a mathematical function that is definedfor any Vector representation: the geometric projection onto theith Cartesian axis.

,"' (VV x^ •

,'/ x,

Projecting a vector (3D)

The this reference. ThemagnitudeO and di recti on() methods in Vector makeuse of the name this. Java provides the this keyword to give us a way to referwithin the code of an instance method to the object whose name was used to invoke this method. You can use this in code in the same wayyou use any othername. Some Javaprogrammers always use thi s to refer to instance variables. Theirscope is the whole class, and this policyis easyto defend because it documents references to instance variables. However, it does result in a surfeit of thi s keywords,so we take the opposite tack and use thi s sparinglyin our code.

Why go to the trouble of using a Vector data type when all of the operations areso easily implemented with arrays? Bynow the answerto this question should beobvious to you: to enable modular programming,facilitate debugging, and clarifycode. The array is a low-level Java mechanism that admits all kinds of operations.Byrestrictingourselves to just the operations in the Vector API (whichare the onlyones that we need, for many clients), we simplify the process of designing, implementing, and maintaining our programs. Because the type is immutable, we canuse it as we use primitive types. For example,when we pass a Vector to a method,we are assured its value will not change,but we do not have that assurance with anarray. Afteryou have seenseveral more examples of object-oriented programming,we will discuss some more nuances in support of the assertion that it simplifiesdesign, implementation,and maintenance. In the case ofVector, writingprogramsthat use Vector and well-defined Vector operationsis an easy and natural waytotake advantage of the extensive amount of mathematical knowledge that has beendeveloped around this abstract concept.


Inheritance Java provides language support for defining relationships amongobjects, known as inheritance. Software developers use thesemechanismswidely, soyouwillstudythem in detailifyoutakea coursein software engineering. Generally,effective use of such mechanisms is beyond the scope of this book, but we brieflydescribe them here because there are a few situations where you may encounterthem.

Interfaces. Interfaces provide a mechanism for specifying a relationship betweenotherwise unrelated classes, by specifying a set of common methods that each implementingclass must contain.We referto this arrangement as interface inheritancebecause an implementing class inherits methods that are not otherwise in its APIthrough the interface.This arrangement allows us to write client programs that canmanipulate objectsof varying types,by invokingmethods in the interface.Aswithmost new programming concepts, it is a bit confusing at first, but will make senseto you after you have seen a fewexamples.

Comparable. One interface that you are likely to encounteris Java's Comparabl einterface. The interface associates a natural order for values within a data type, using a method named compareToO,as describedin the following API:

public interface Comparable<Key>

i nt compareTo (Key b) compare this object with bfor order

APIforJava's Comparable interface

The <Key> notation, which we will introduce in Section 4.3, ensures that the twoobjects being compared have the sametype.Assuming a and b are objects of thesame type, a. compareTo(b) must return:

• A negativeinteger if a is less than b• A positive integer if if a greater than b• Zero if a is equalto b

Additionally, the compareToO method must be consistent:for example, if a is lessthan b, then b must be greater than a. A class that implements the Comparableinterface—such as String, Integer, or Double—promises to include a compareToO method according to these rules.Asexpected, the natural order for stringsis alphabetical and for integers is ascending.


To illustrate the utilityof having such an interface, we start by considering a sortfilter forStri ng objects. Thefollowing code takes an integer Nfromthe command-line, reads in Nstrings from standard input, sorts them,and prints the strings onstandard output in alphabetical order.

import java.util.Arrays;

public class SortClient{


int N = Integer.parselnt(args[0]);String[] names = new String[N];for (int i = 0; i < N; i++)

names[i] = Stdln.readStringO ;Arrays.sort(names);for (int i =0; i < N; i++)

StdOut.pri ntln(names[i]);}

}

Wewill examine sorting in detail in Section 4.2, so for the moment, we use a staticmethod Arrays. sort () from Java's java. uti 1 library. Now, if we replace the array input with the three lines

Integer[] names = new Integer[N];for (int i = 0; i < N; i++)

names[i] = Stdln.readlntO ;

SortClient sorts Integer values from standard input. You might speculate thatArrays. sort () has overloaded implementations, one for Stri ng and one for Integer. But this is not the case because Arrays.sort() must be able to sort anarrayof any type that implements the Comparabl e interface (even a data type notcontemplated when writing the sorting method). To do so, the code in Arrays.sort() declares variables of type Comparable—such variables may store valuesof type String, Integer, Double, or of any type that implements the Comparabl e interface. When you invoke the compareToO method of such a variable, Javaknows whichcompareToO method to call, because it knows the type of the invoking object. This powerful programming mechanism is known aspolymorphism ordynamic dispatch.


To make a class implement the Comparable interface, include the phrase implements Comparabl e after the class definition, and then add a compareTo () method.For example, modify Counter (Program 3.3.2) as follows:

public class Counter implements Comparable<Counter>{

public int compareTo(Counter b){

if (count < b.count) return -1else if (count > b.count) return +1else return 0

}

}"""Sinceyou are implementing compareToO, you have the flexibility to specify anysort order whatever. For example, you might create a version of Counter to allowclients to sort Counter values in decreasing order (perhaps for a voting application), by changing the compareToO method as follows:

public int compareTo(Counter b){if (count < b.count) return +1else if (count > b.count) return -1else return 0

}

For another example, ifyou were to modify StockAccount as follows:

public class StockAccount implements Comparable<StockAccount>{

public int compareTo(StockAccount b)

{return name.compareTo(b.name);

}

}"

you could then sort an array of StockAccount values by account name with Arrays. sort(). (Note that this compareToO implementation for StockAccount


uses Java's compareToO method for Stri ng.) Thisabilityto arrange to write a client to sort any type of data is a persuasive exampleof interface inheritance.

Computing with functions. Often, particularly in scientific computing, we wantto compute withfunctions: wewant to compute integralsand derivatives, find roots,and so forth. In someprogramming languages, known as functional programminglanguages, this desire alignswith the underlyingdesign of the language, which uses computingwith functions to substantially simplify clientcode. Unfortunately, methods are notfirst-classobjects inJava. Asan example,consider the problem of estimating the integral of a positivefunction (area under the curve) in an interval (a, b).This computation is known as quadrature or numerical integration. One simplemethod for estimatingthe integralis the rectangle rule: compute the total area of Nequally-spaced rectangles under the curve. To implement this rule, wemight try towritethe following codeto approximate the value of an integral by:

public double integrate(double f(double x),double a, double b, int N)

{double delta = (a - b)double sum =0.0;for (int i =0; i

sum += delta * f(a + delta * (i + 0.5));}

Such a method would enable client code such as this:

/ N;

< N; i++)f(a + delta

\H

Th^,Approximating an integral

integrate(Gaussian.phi(), a, b, N)

Unfortunately, this code isnot legal in Java. You cannot pass methods asarguments.We can getaround this restriction bydefining an interface for functions and usingthat interface to implement i nteg rate (). You can find that solution on the book-site, along with many examples of methods and classes that involve computingwith functions in Java, which willbe of interest if you plan to take future courses inscientific computing.

Event-based programming. Another powerful example of thevalue of interfaceinheritance is its use in event-based programming. In a familiar setting, consider


the problem of extendingDraw to respond to user input such as mouse clicks andkeystrokes. One wayto do so is to define an interface to specify whichmethods thedraw package should call when user input happens. The descriptive term callbackis sometimes used to describe a call from a method in one class to a method in

another class through an interface. You can find on the booksite an example interface DrawListener and information on how to write code to respond to usermouse clicks and keystrokes within Draw. java. You will find it easyto write codethat createsa Draw object and includesa method that the Draw method can invoke(callback your code) to tell your method the character typed on a user keystrokeevent or the mouse position on a mouse click. Writing interactive code is fun butchallenging becauseyou haveto plan for allpossible user input actions.

Subtyping. Another approach to enabling codereuse is known as subtyping. It isa powerful technique that enables a programmer to change the behavior of a classand add functionality without rewriting the entireclass from scratch. The ideais todefine a new class (subclass, or derived class) that inherits instance variables and instancemethods from another class (superclass, or base class). The subclass containsmore methods than the superclass. Subtypingis widelyused by systems programmers to build so-called extensible libraries. The idea is that one programmer (evenyou) canaddmethods toalibrarybuiltbyanotherprogrammer (or, perhaps, ateamof systems programmers), effectively reusing the code in a potentially huge library.Thisapproach iswidely used, particularly in the development of userinterfaces, sothat the largeamount of coderequiredto provideall the facilities that usersexpect(drop-downmenus,cut-and-paste, access to files, and so forth) canbe reused. Theuseof subtypingis controversial amongsystems programmers (its advantages overinterface inheritance are debatable), and we do not use it in this book, because itgenerally works against encapsulation. Subtyping makes modular programmingmore difficult for two reasons. First, any change in the superclass affects all subclasses. The subclass cannot be developed independently of the superclass; indeed,it is completely dependent on the superclass. This problem is known as the fragilebase class problem. Second, the subclass code,having access to instance variables,can subvert the intention of the superclass code. For example, the designer of aclass such asVector mayhavetaken greatcare to make the Vector immutable, buta subclass, with full access to the instance variables, can just change them. However, certain vestiges of the approachare built into Java and therefore unavoidable.Specifically, every class is a subtype of Java's Object class. This structure enables


implementation of the "convention"that everyclass includes an implementationsof toStri ng(), equal s(), hashCodeO (a method that we will encounter later inthis sectionand in Chapter 4), and several other methods. Every class inherits thesemethods from Object through subtyping.

Application: data miimimg To illustrate some of the concepts discussed in thissection in the context of an application, we next consider a software technologythat is proving important in addressing the daunting challenges of data mining, aterm that is widelyused to describe the process of searching through the massiveamounts of information now accessible to everyuser on the web (not to mentionour own computers). This technologycan serve as the basisfor dramatic improvements in the quality of web search results,for multimedia information retrieval, forbiomedical databases, for plagiarism detection, for research in genomics, for improved scholarship in many fields, for innovationin commercial applications, forlearning the plansof evildoers, and for manyother purposes. Accordingly, there isintenseinterestand extensive ongoingresearch on data mining.

You have directaccess to thousandsof files on your computerand indirect access to billions of files on the web. As youknow, these files are remarkably diverse:there are commercial web pages, music and video, email, program code, and allsorts of other information. For simplicity, we will restrict attention to text documents (though the method wewillconsiderapplies to pictures,music,and all sortsof other files aswell). Even withthis restriction, thereisremarkable diversity in thetypes of documents. For reference, you can find these documents on the booksite:Our interestis in finding efficient ways to search through the files usingtheir content to characterize documents. One fruitful approach to this problem is to as-

file name description

Constitution.txt legal document

TomSawye r. txt American novel

HuckFinn.txt

Prejudice.txt

Picture.java

DDIA.csv

Amazon.html

ACTG.txt

American novel

English novel

Java code

financialdata

webpagesource

virusgenome

sampletext

. of both Houses shall be determined by .

."Say, Tom, let ME whitewash a little." .

.was feeling pretty good after breakfast.

. dared not even mention that gentleman..

.String suffix = filename.substring(file.

.Ol-Oct-28,239.43,242.46,3500000,240.01 .

.<table width="100%" border="0" cellspac.

.GTATGGAGCAGCAGACGCGCTACTTCGAGCGGAGGCATA.

Some text documents

439


sociate with each document a vector known as a profile, which is a function of itscontent. The basic idea is that the profile should characterize a document, so thatdocuments that are different haveprofilesthat are different and documents that aresimilar have profiles that are similar.You probably are not surprised to learn thatthis approach can enable us to distinguish among a novel, a Java program, and agenome, but you might be surprised to learn that content searches can tell the differencebetween novelswritten by different authors and can be effective as the basisfor many other subtle search criteria.

To start, we need an abstraction for documents. What is a document? Whatoperations do we want to perform on documents? The answers to these questionsinform our design and therefore, ultimately, the code that we write. For the purposes of data mining, it is clear that the answer to the first question is that a document is defined by an input stream. The answer to the second question is that weneed to be able to compute a number (for example, a doubl e value) to measure thesimilarity between a documentand anyother document.Theseconsiderations leadto the following API.

public class Document

Document(String name, int k, int d)

doubl e si mTo(Document doc) similarity measure between this document and doc

Stri ng name () name ofthis document

APIfor documents (seeProgram 3.3.4)

The arguments of the constructor are a file or website name (for useby In) and twointegers that control the quality of the search. Clients can use simToO to determine the extent of similarity between this Document and any other Document on ascaleof 0 (not similar) to 1 (similar).This simple data type provides a good separation between implementing a similaritymeasure and implementing clients that usethe measure to search among documents.

Computing profiles Computing the profile is the first challenge. Our first choiceis to use Vector to represent a document's profile. Butwhat information should gointo computing the profileand how do we compute the value of the Vector profileof a Document (in the constructor)? Many different approaches have been studied,and researchers are still activelyseeking efficient and effective algorithms for this


w^^^^^^^^^^^^^^^s^^mmm^<$?<

Program 33A Document

public class Document

{private final String id;private final Vector profile;

public Document(String name, int k, int d){

id = name;String s = (new In(name)).readAll();int N = s.1ength();doubled freq = new double[d];for (int i = 0; i < N-k; i++){

int h = s.substring(i, i+k).hashCode();freq[Math.abs(h % d)] += 1;

id

profile

file nameor URL

unit vector

name

k

d

s

N

freq[]

h

document name

length ofgram

dimension

entire document

document length

hash frequencies

hash for k-gram

}profile = (new Vector(freq)).direction();

}

public double simTo(Document doc){ return profile.dot(doc.profi1e); }

public String name(){ return id; }


String name = args[0];int k = Integer.parselnt(args[l]);int d = Integer.parselnt(args[2]);Document doc = new Document(name, k, d);StdOut.pri ntln(doc.profi1e);

}

zm^t&for&^&^S^WMSzk

}

This Vector client creates a unit vector from a document's k-grams that clients can use tomeasure its similaritywith otherdocuments (see text).

% more genomeA.txtATAGATGCATAGCGCATAGC

% java Document genomeA.txt 2 16[ 0 0 0.51 0.39 0.39 0 0 0 .13 0.39 0 0 0.13 0.13 0.51 0 0 ]


task.Our implementation Document (Program3.3.4) usesa simplefrequency countapproach. The constructor has two arguments, an integer k and a vector dimension d.It scansthe document and examinesall of the k-grams in the document: thesubstrings of lengthkstartingat each position. In its simplest form, the profile is avector that gives the relative frequency of occurrence of the fc-grams in the string:an entryforeach possible fc-gram giving the numberof fc-grams in the contentthathave that value. For example, suppose that weuse k= 2 in genomic data,with d =16 (there are 4 possiblecharactervaluesand therefore 16 possible 2-grams). The 2-gram AT occurs4 times in the string ATAGATGCATAGCGCATAGC, so,for example, the vector entry corresponding to ATwould be 4. Tobuild the frequency vector, we needto be able to convert each of the fc-grams into aninteger between 0 and 15 (thisinteger function of astring isknownasa hash value). Forgenomic data,this is an easy exercise (see Exercise 3.3.26). Then,we can compute an array to build the frequencyvector in one scan through the text, incrementingthe array entry corresponding to each fc-gram encountered. It would seem that we lose information

by disregarding the order of the fc-grams, but theremarkable fact is that the information content of

that order is lower than that of their frequency. AMarkov model paradigm not dissimilar from theone that we studied for the random surfer in Sec

tion 1.6 can be used to take order into account—

such models are effective, but much more workto implement. Encapsulating the computation inDocument gives ustheflexibility to experiment withvarious designs without needing to rewrite Document clients.

ClIICGGIII

GGAACCGAAG

CCGCGCGTCT

ATAGATGCAT TGTCTGCTGC

hash

AGCGCATAGC AGCATCGTTC

2-gram count unit count unit

AA 0 0 0 2 .137

AC 1 0 0 1 .069

AG 2 4 .508 1 .069

AT 3 3 .381 2 .137

CA 4 3 .381 3 .206

CC 5 0 0 2 .137

CG 6 0 0 4 .275

CT 7 1 .127 6 .412

GA 8 3 .381 0 0

GC 9 0 0 5 .343

GG 10 0 0 6 .412

GT 11 1 .127 4 .275

TA 12 1 .127 2 .137

TC 13 4 .508 6 .412

TG 14 0 0 4 .275

TT 15 0 0 2 .137

Profilinggenomic data

Hashing. For ASCII text strings there are 128 different possible char values foreach character, so there are 128* possible fc-grams, and the dimension dwould haveto be 128* for the simple scheme just described. Thisnumber is prohibitively largeeven for moderately large fc. For Unicode, with 65,536 characters, even 2-gramslead to huge vector profiles. To ameliorate this problem, we use hashing, a fun-


damental operation related to search algorithms that we consider in Section 4.4.Indeed, the problem of convertinga string to an integerindex is so important thatit is built into Java. As just mentioned in our discussion of inheritance, all objectsinherit from Object a method hashCodeO that returns an int value. Given anystring s, we compute Math.abs (s. hashcode() % d). This value is an integer between0 and d— 1 that we can use as an indexinto an array to compute frequencies.The profilethat weuse is the direction of the vectordefined by frequencies of thesevalues for all fc-grams in the document (the unit vector with the same direction).

Comparingprofiles. The second challenge is tocompute asimilarity measure between two profiles. Again, there are many different ways to compare two vectors.Perhaps the simplest is to compute the Euclidean distance between them. Givenvectorsx and y, this distance is defined by:

|x-y| = ((x0-y0)2 + {xx-yx)2 + ...+ (x^ -yd.x)2)^

You are familiar with this formula for d = 2 or d = 3. With Vector, the distance iseasy to compute. If x and y are two Vector values, then x. mi nus (y) .magnitude ()is the Euclidean distance between them. If documents are similar, weexpect their profiles to be similar and the distance between them to be %mor.e.docf •txtlow. Another widely used similarity measure, known as the cosine simi- jomSawyer .txtlarity measure, is even simpler: sinceour profiles are unit vectors with HuckFi nn.txtnonnegative coordinates, their dot product Pr.eJ udl C(: •txt

0 r Picture.java

x -y = x0y0 + x$x + ... + xd_$d_x

is a number between0 and 1.Geometrically, this quantity is the cosineof the angle formed by the two vectors (seeExercise 3.3.12).The moresimilar the documents, the closerwe expectthis measure to be to 1.

Comparing allpairs. CompareAll (Program 3.3.5) is a simple and useful Document client that provides the information needed to solve the following problem:given a setof documents, findthe twothat aremostsimilar. Since thisspecificationis a bit subjective, CompareAl 1 prints out the cosine similarity measurefor allpairsof documents on an input list.For moderate-size fc and d,the profiles do a remarkablygood job of characterizing our sample set of documents. The results saynotonlythat genomicdata, financial data,Java code, and websourcecodearequite differentfrom legal documentsand novels, but also that Tom Sawyer and Huckleberry

DJIA.csv

Amazon.html

ACTG.txt


llliPlfPP^$S!!^

i

II

#3

Program 3.3.5 Similarity detection

public class CompareAll{

public static void main(String[] args){int k = Integer.parselnt(args[0]);int d = Integer.parselnt(args[1]);int N = Stdln.readlntO;Document [] a = new Document[N]; <*for (int i = 0; i < N; i++)

a[i] = new Document(Stdln.readStringO , k, d) ;StdOut.print(" ");for (int j = 0; j < N; j++)

StdOut.printf(M %.4s", a[j].name());StdOut.println();for (int i = 0; i < N; i++){

StdOut.printf("%.4s", a[i].name());for (int j = 0; j < N; j++)

StdOut.printfCJa.Zf", a[i] .simTo(a[j])) ;StdOut.println();

k

d

N

a[]

length ofgram

dimension

numberof documents

all documents

}}

}

This Document client reads a document list from standard input, computes profiles based onk-gram frequencies forall the documents, and prints a matrix ofsimilarity measures betweenallpairs ofdocuments. It takes two arguments from the command line: the value ofk andthedimension d of theprofiles.

% java CompareAll 5 10000 < docs.txt

iCons TomS Huck Prej Pict DJIA Amaz ACTG

Cons 1.00 0.66 0.60 0.64 0.17 0.18 0.21 0.11

TomS 0.66 1.00 0.93 0.88 0.10 0.24 0.18 0.14 1Huck 0.60 0.93 1.00 0.82 0.07 0.23 0.16 0.12 i

i.Prej 0.64 0.88 0.82 1.00 0.10 0.25 0.19 0.15

Pict 0.17 0.10 0.07 0.10 1.00 0.05 0.37 0.03

11D3IA 0.18 0.24 0.23 0.25 0.05 1.00 0.16 0.11

Amaz 0.21 0.18 0.16 0.19 0.37 0.16 1.00 0.07

ACTG 0.11 0.14 0.12 0.15 0.03 0.11 0.07 1.00p.

I1ii"

m

fit

i


Finnare much more similar to each other than to Pride andPrejudice. A researcherin comparative literature could use this program to discoverrelationships betweentexts;a teacher could also use this program to detect plagiarismin a set of studentsubmissions (indeed, many teachers do use such programs on a regular basis); ora biologist could use this program to discover relationships among genomes. Youcan find many documents on the booksite (or gather your own collection) to testthe effectiveness of CompareAl 1 for various parameter settings.

Searching for similar documents. Another natural Document client is one thatuses profiles to search among a large number of documents to identify those thatare similar to a given document. For example, web search engines uses clients ofthis type to present you with pages that are similar to those you have previouslyvisited, online book merchants use clients of this type to recommend books thatare similar to ones you have purchased, and social networking websites use clientsof this type to identify people whose personal interests are similar to yours. SinceIn can take web addresses instead of file names, it is feasible to write a programthat can surf the web,compute profiles,and return links to pagesthat have profilesthat are similar to the one sought. Weleavethis client for a challenging exercise.

This solution is just a sketch. Many sophisticated algorithms forefficiently computing profiles and comparing them are still beinginvented and studied by computer scientists. Our purpose here isto introduce you to this fundamental problem domain while atthe same time illustrating the power of abstraction in addressing / primitive typey^a computational challenge. Vectors are an essential mathematical / bitabstraction, and we can build search solutions by developing layers of abstraction: Vector is built with the Java array, Document is / ->built with Vector, and client code uses Document. As usual, we have

spared you from a lengthy account of our many attempts to develop these APIs,but you can see that the data types are designed in response to the needs of theproblem, with an eye toward the requirements of implementations. Identifyingand implementing appropriate abstractions is the key to effective object-orientedprogramming. The power of abstraction—in mathematics, physical models, andin computer programs—pervades these examples.Asyou become fluent in developing data types to address your own computational challenges, your appreciation for this power will surely grow.


Design-by-contract. To conclude, we briefly discuss Java language mechanisms that enable you to verify assumptions about your program as it is running.For example, if you have a data type that represents a particle, you might assertthat its mass is positive and its speed is less than the speed of light. Or if you have amethod to add two vectors of the same length, you might assert that the length ofthe resulting vector also has the same length.

Exceptions. An exception isa disruptive eventthat occurswhilea program is running, often to signal an error. The action taken is known as throwing an exception.We have already encountered exceptions thrown by Java system methods in thecourse of learning to program: StackOverflowException, Di videByZeroExcep-tion, NullPointerException, and ArrayOutOfBoundsException are typicalexamples. You can also create your own exceptions. The simplest kind is a Run-timeException that terminates execution of the program and prints out an errormessage.

throw new RuntimeException("Error message here.");

It is good practice to use exceptions when they can be helpful to the user. For example, in Vector (Program 3.3.3),we should throw an exception in pi us() if thetwo Vectors to be added have different dimensions. To do so, we insert the follow

ing statement at the beginning of pi us ():

if (coords.length != b.coords.length)

throw new RuntimeException("Vector dimensions disagree.");

This leads to a more informative error message than the ArrayOutOfBoundsEx-cepti on than the client would otherwise receive.

Assertions. An assertion is a boolean expression that you are affirming is true atthat point in the program. If the expression is f al se, the program will terminateand report an error message. Assertions are widely used by programmers to detectbugs and gain confidence in the correctness of programs. They also serve to document the programmer's intent. For example,in Counter (Program 3.3.2),we mightcheck that the counter is never negativeby adding the following assertion as the laststatement in i ncrement ():

assert count >= 0;


which would identify a negativecount. You can alsoadd an optional detail message,such as

assert count >= 0 : "Negative count detected in increment()";

to help you locate the bug. By default, assertions are disabled, but you can enable them from the command line by using the -enabl easserti ons flag (-ea forshort). Assertions are for debugging only:your program should not rely on assertions for normal operation since they may be disabled. When you take a course insystems programming, you will learn to use assertions to ensure that your codenever terminates in a systemerror or goesinto an infinite loop. One model, knownas the design-by-contract model of programming, expresses the idea. The designerof a data type expresses a precondition (the condition that the client promises tosatisfywhen callinga method), a postcondition (the condition that the implementation promises to achieve when returning from a method), invariants (any condition that the implementation promises to satisfy while the method is executing),and side effects (any other change in state that the method could cause). Duringdevelopment, these conditions can be tested with assertions. Many programmersuse assertions liberally to aid in debugging.

The language mechanisms discussed throughout this section illustrate that effec

tive data-type design takes us into deep water in programming-language design.Experts are still debating the best waysto support some of the design ideas that weare discussing.Why does Javanot allowfunctions as arguments?Why does Matlabnot support mutable data types? As mentioned early in Chapter 1, it is a slipperyslope from complaining about features in a programming language to becominga programming-language designer. If you do not plan to do so, your best strategyis to use widely available languages. Most systems have extensive libraries that youcertainly should use when appropriate, but you often can simplifyyour client codeand protect yourselfby building abstractions that can easilytransport to other languages. Your main goal is to develop data types so that most of your work is doneat a level of abstraction that is appropriate to the problem at hand.


W+ A

Q. What happens if I try to access a private instance variable or method fromanother file?

A. You geta compile-timeerror that says the given instancevariable or method hasprivate accessin the given class.

Q. The instance variables in Complex are private, but when I am executing themethod ti mes () for a Compl ex object a, I can access object b's instance variables.Shouldn't they be inaccessible?

A. The granularity of private access is at the class level, not the instance level. Declaring an instance variable as private means that it is not directly accessible fromany other class. Methods within the Compl ex class can access (read or write) theinstance variables of any instance in that class. It might be nice to have a more restrictive access modifier, say, superprivate—that would make the granularity atthe instance level so that only the invoking object can access its instance variables,but Javadoes not have such a facility.

Q I see the problem with the ti mes () method in Compl ex. It needs a constructorthat takes polar coordinates as arguments. How can we add such a constructor?

A. That is a problem since we already have one constructor that takes two realarguments. A better design would be to have two methods createRect(x, y)and createPol ar (r, theta) in the API that create and return new objects. Thisdesign is better because it would provide the client with the capability to switch topolar coordinates. This example demonstrates that it is a good idea to think aboutmore than one implementation when developinga data type.

Q. Is there a relationship between the Vector in this section and the Vector classin the Java library?

A. No.Weuse the name becausethe term vector properly belongs to linear algebraand vector calculus.

Q. What is a deprecated method?

A. A method that is no longer fully supported, but kept in an API to maintain


compatibility. For example, Javaonce included a method Character.isSpace(),and programmers wrote programs that relied on using that method's behavior.When the designers of Javalater wanted to support additional Unicode whitespacecharacters, they could not change the behavior of i sSpace () without breaking client programs. So,instead, they added a new method Characte r. i sWhi teSpace ()and deprecated the old method. As time wears on, this practice certainly complicates APIs.

Q. I am interested in the methods that all objects inherit from Object. We havebeen using toStri ng() and the use of hashCodeO in Document is interesting, butwhat about equal s ()? Isn't it important for me to know how about that?

A. Well, yes, in principle, but you would be very surprised at how difficult it is toproperly implement equal s(), even for simple objects. For example, the followingis an implementation of equal s () for Counter:

public boolean equals(Object y){

if (y == this) return true;if (y == null) return false;if (y.getClass() != this.getClassO) return false;Counter b = (Counter) y;return (count == b.count);

}

449


,0Exerclmlsl.

3.3.1 Represent a point in time by using an i nt to store the number of secondssince January 1,1970. When will programs that use this representation face a timebomb? How should you proceed when that happens?

3.3.2 Create a data type Location for dealing with locations on Earth usingspherical coordinates (latitude/longitude). Include methods to generate a randomlocation on the surface of the Earth, parse a location "25.344 N, 63.5532 W", andcompute the great circle distance between two locations.

3.3.3 Create a data type for a three-dimensional particle with position (rx, ry,rz), mass (m), and velocity (vx> vy> vz). Include amethod toreturn its kinetic energy,which equals 1/2 m(vx2 + vy2 + vz2). Use Vector.

3.3.4 If you know your physics, develop an alternate implementation for youdata type of the previous exercise based on using the momentum (px, py, pz) as aninstance variable.

3.3.5 Develop an implementation of Hi stogram (Program 3.2.3) that uses Counter (Program 3.3.2).

3.3.6 Givean implementation of mi nus () for Vector solelyin terms of the otherVector methods, such as di recti on () and magnitudeO.

Answer:

public Vector minus(Vector b)

{return this.plus(b.times(-1.0));

}

The advantage of such implementations is that they limit the amount of detailedcode to check; the disadvantage is that they can be inefficient. In this case, pi us ()and timesO both create new Vector objects, so copying the code for pi us() andreplacing the minus sign with a plus sign is probably a better implementation.

3.3.7 Implement the method toStri ng() for Vector.


3.3.8 Add the code necessaryto makeVector implement Comparabl e (using thevalueof the magnitude to determine the sort order) and write a test client that takesk and Nas command-line arguments, reads Nfc-dimensional vectors from standardinput, sorts them with Arrays.sortO, and prints the sorted result on standardoutput.

3.3.10 Implement a data type Vector2Dfor two-dimensionalvectors that has thesame API as Vector, except that the constructor takes two doubl e values as arguments. Use two doubl e values (instead of an array) for instance variables.

3.3.11 Implement the Vector2D data type of the previous exerciseusing one Compl ex value as the only instance variable.

3.3.12 Prove that the dot product of two two-dimensional unit-vectors is the cosine of the angle between them.

3.3.13 Implement a data type Vector3D for three-dimensional vectors that hasthe same API as Vector, except that the constructor takes three double values asarguments. Also, add a cross product method: the cross product of two vectors isanother vector, defined by the equation

aXb = c|a||b|sin6

where c is the unit normal vector perpendicular to both a and b, and 0 is the anglebetween a and b. In Cartesian coordinates, the followingequation defines the crossproduct:

(a0, av a2) X (2?0, bv b2) = {ax b2 -a2 bv a2 b0 -aQbv a0 bx -ax b0)

The cross product arises in the definition of torque, angular momentum, and vector operator curl.Also, |a X b| is the areaof the parallelogram with sidesa and b.

3.3.14 Use assertions and exceptions to develop an implementation of Rati onal(see Exercise 3.2.7) that is immune to overflow.

3.3.15 Add code to Counter to throw a RuntimeException if the client tries toconstruct a Counter object using a negative value for max.


^ata-t^g0Destg^JExerci^^

This listof exercises is intended to give you experience in developing data types. Foreach problem, design oneor more APIs with API implementations, testing your design decisions byimplementing typical client code. Some of the exercises require eitherknowledge ofaparticular domain ora search for information about it on the web.

3.3.16 Statistics. Developa data type for maintaining statistics of a set of doubl evalues.Provide a method to add data points and methods that return the number ofpoints, the mean, the standard deviation,and the variance. Developtwo implementations: one whose instance values are the number of points, the sum of the values,and the sum of the squaresof the values, and another that keepsan array containingall the points. For simplicity, you may take the maximum number of points in theconstructor. Your first implementation is likely to be faster and use substantiallyless space,but is also likelyto be susceptible to roundoff error. See the booksite fora well-engineered alternative.

3.3.17 Genome. Develop a data type to store the genome of an organism. Biologists often abstract the genome to a sequence of nucleotides (A, C, G, or T). The datatype should support the methods addCodon(char c) andnucleotideAt(int i),as well as findGeneO (see Program 3.1.8). Develop three implementations. First,use one instance variable of type String, implementing addCodon() with stringconcatenation. Each method call takes time proportional to the size of the currentgenome. Second, use an array of characters, doubling the sizeof the array each timeit fills up. Third, use a boo! ean array, using two bits to encode each codon.

3.3.18 Time. Develop a data type for the time of day.Provide client methods thatreturn the current hour, minute, and second, as well as toStri ng() and compareToO methods. Develop two implementations: one that keeps the time as a singlei nt value (number of seconds since midnight) and another that keeps three i ntvalues, one each for seconds, minutes, and hours.

3.3.19 Vectorfields. Developa data type for forcevectors in two dimensions. Provide a constructor, a method to add two vectors, and an interesting test client.

3.3.20 VIN number. Develop a data type for VIN numbers that can report backall relevant information.


3.3.21 Generating random numbers. Develop a data type for random numbers.(Convert StdRandom to a data type). Instead of using Math. random(), base yourdata type on a linear congruential random number generator. This method tracesto the earliest days of computing and is also a quintessential example of the valueof maintaining state in a computation (implementing a data type). Togenerate random i nt values, maintain an i nt value x (the value of the last "random" numberreturned). Each time the client asks for a new value, return a*x + b for suitablychosen values of a and b (ignoring overflow). Usearithmetic to convert these values to "random" values of other types of data. Assuggestedby D. E. Knuth, use thevalues 3141592621 for a and 2718281829 for b,or check the booksite for other suggestions. Providea constructor allowing the clientto start with an i nt valueknownas a seed (the initial value of x). This ability makes it clear that the numbers arenot at all random (even though they may have many of the properties of randomnumbers) but that fact can be used to aid in debugging, since clients can arrange tosee the same numbers each time.

453


IjFcafiSi^teiifils

3.3.22 Encapsulation. Is the following class immutable?

import java.util.Date;public class Appointment{

private Date date;private String contact;

public Appointment(Date date){

// Code to check for a conflict.this.date = date;this.contact = contact;

}public Date getDateO{ return date; }

}

Answer. No. Java's Date class is mutable.The method setDate (seconds) changesthe value of the invokingdate to the number of milliseconds sinceJanuary 1,1970,00:00:00 GMT. This has the unfortunate consequence that when a client gets adate with d = getDateO, the client program can then invoke d. setDate() andchange the date in an Appoi ntment object type, perhaps creating a conflict. In adata type, we cannot let references to mutable objects escapebecause the caller canthen modify its state. One solution is to createa defensive copy of the Date beforereturning it using new Date (date. getTi me () ) ; and a defensive copy when storing it via thi s. date = new Date(date. getTi me ()). Many programmers regardthe mutability of Date as a Javadesign flaw. (Gregori anCal endar is a more modern Java library for storing dates,but it is mutable, too.)

3.3.23 Date. Develop an implementation of Java's Date API that is immutableand therefore corrects the defectsof the previous exercise.

3.3.24 Calendar. Develop Appointment and Cal endar APIs that can be used tokeeptrack of appointments (byday)in a calendaryear. Your goalis to enableclientsto schedule appointments that do not conflict and to report current appointmentsto clients.


3.3.25 Vectorfield. Avector field associates a vector withevery point in a Euclidean space. Write a version of Potenti al (Program 3.1.7) that takes as input a gridsize N, computes the Vector value of the potential due to the point charges at eachpoint in an N-by-N grid of equally spaced points, and draws the unit vectorin thedirection of the accumulated field at each point. (Modify Charge to return a Vector.)

3.3.26 Genomeprofiling. Writeafunction hash() that takes asargumenta fc-gram(stringof length fc) whose characters are all A, C, G, or Tand returns an i nt valuebetween 0 and 4k that corresponds to treating the string as base-4 numbers with{A, C, G, T} replacedby {0,1,2,3}, respectively, as suggested by the table in the text.Next, write a function unhash() that reverses the transformation. Use your methods to create a classGenome that is like Document, but is based on exact counting offc-grams in genomes. Finally, writea version of CompareAl 1 for Genome objects anduse it to look for similarities among the set of genome files on the booksite.

3.3.27 Profiling. Pick an interesting set of documents from the booksite (or usea collection of your own) and run CompareAl 1 with various values of the two parameters, to learn about their effect on the computation.

3.3.28 Multimedia search. Develop profiling strategies for sound and pictures,and use them to discoverinteresting similaritiesamong songs in the music libraryand photos in the photo album on your computer.

3.3.29 Data mining. Write a recursive program that surfs the web, starting at apage given as the first command-line argument, looking for pages that are similarto the page given as the second command-line argument, as follows: to process aname, open an input stream, do a readAl1(), profile it, and print the name if itsdistance to the target page is greater than the threshold valuegivenas the third command-line argument. Then scan the page for all strings that contain the substringhttp: // and (recursively) process pages with those names. Note: This programcould read a very large number of pages!

455


3.4 Case Study: N-body Simulation

Severalof the examples that weconsideredin Chapters 1and 2 are better expressedas object-oriented programs. For example,BouncingBal1 (Program 1.5.6)is naturally implemented as a data type whose values are the position and the velocityof the ball and a client that calls instance

methods to move and draw the ball. Such „, t _ . . ' ,- itr ii. 3.4.1 Gravitational body 460

a data type enables, for example, clients 3A2 N_body simulation 463that can simulate the motion of several _ ....,„ , ^ ^..xr... Programs in this sectionballs at once (see Exercise 3.4.1). Similarly, our case study for Percolation inSection 2.4 certainly makes an interesting exercise in object-oriented programming, as does our random surfer casestudy in Section 1.6.Weleavethe former foran exercise (see Exercise 3.4.2) and will revisit the latter in Section 4.5. In this section, we consider a new examplethat exemplifies object-oriented programming.

Our task is to write a program that dynamically simulates the motion of Nbodies under the influence of mutual gravitational attraction. This problem wasfirst formulated by Newton over 350 years ago, and it is still studied intensely today.

What is thesetof values, andwhataretheoperations on those values? One reason that this problem is an amusing and compelling example of object-orientedprogramming is that it presents a direct and natural correspondence between physical objects in the real world and the abstract objects that we use in programming.The shift from solving problems by putting together sequences of statements to beexecuted to beginning with data type design is a difficult one for many novices.Asyou gain more experience, you will appreciate the value in this approach to computational problem-solving.

We recall a fewbasic concepts and equations that you learned in high schoolphysics. Understanding those equations fully is not required to appreciate thecode—because of encapsulation, these equations are restricted to a few methods,and because of data abstraction, most of the code is intuitive and will make sense toyou. In a sense,this is the ultimate object-oriented program.

3.4 Case Study: N-Body Simulation

N-body simmlatioB The bouncing ball simulation of Section 1.5 is based onNewton'sfirst lawof motion: a body in motion remains in motion at the same velocity unless acted on by an outside force. Embellishing that example to include Newton's second law of motion (which explains how outside forces affect velocity) leadsus to a basic problem that has fascinated scientists for ages. Given a system of Nbodies, mutually affected by gravitational forces, the problem is to describe theirmotion. The same basic model applies to problems ranging in scale from astrophysics to molecular dynamics.

In 1687, Isaac Newton formulated the principles governing the motion oftwo bodies under the influence of their mutual gravitational attraction, in his famous Principia. However, Newton was unable to develop a mathematical description of the motion of three bodies. It has since been shown that not only is there nosuch description in terms of elementary functions, but also that chaotic behavioris possible, depending on initial values. To study such problems, scientists haveno recourse but to develop an accurate simulation. In this section, we develop anobject-oriented program that implements such a simulation. Scientists are interested in studying such problems at a high degree of accuracy for huge numbers ofbodies, so our solution is only an introduction to the subject, but you are likely tobe surprised at the ease with which we can develop realistic images depicting thecomplexity of the motion.

Body data type. In BouncingBall (Program 1.5.6), we keep the displacementfrom the origin in the double values rx and ry and the velocity in the doublevalues vx and vy, and displace the ball the amount it moves in one time unit withthe statements:

rx =

ry =

rx

ry

vx;

vy;

r + \

457

With Vector (Program 3.3.3), we can keep the position inthe Vector value r and the velocity in the Vector value v,and then displace the body the amount it moves in dt timeunits with a single statement:

r = r.plus(v.times(dt));

In JV-body simulation, we have several operations of thiskind, so our first design decision is to work with Vector values instead of individual component values. This decision Adding vectors to movea ball


leadsto code that is clearer, more compact,and more flexible than the alternative ofworking with individual components. Body (Program 3.4.1) is a Javaclass that usesVector to implement a data type for moving bodies. The values of the data typeare Vector values that carry the body's position and velocity, as well as a doublevalue that carries the mass. The data-type operations allow clients to move and todraw the body (and to compute the force vector due to gravitational attraction ofanother body), as defined by the following API:

public class Body

Body(Vector r, Vector v, double mass)

void move (Vector f, double dt) applyforce f, move bodyfor dt seconds

void draw() draw theball

Vector force From (Body b) force vector between this body andb

APIfor bodies moving under Newton s laws (seeProgram 3.4.1)

Technically, the body's position (displacement from the origin) is not a vector (it isa point in space,not a direction and a magnitude), but it is convenient to representit as a Vector because Vector's operations lead to compact code for the transformation that we need to move the body,as just discussed.When we move a Body, weneed to change not just its position, but also its velocity.

Force and motion. Newton's second law ofmotion says that the force on a body (avector) is equal to the scalar product of its mass and its acceleration (also a vector):f = ma. In other words, to compute the acceleration of a body, we compute the

time t time t+1

newposition is vector sumofoldposition and velocity

stationarybody

Motion neara stationary body

new velocity is vector sum ofold velocityand acceleration


force, then divide by its mass. In Body, the force is a Vector argument f to move(),so that we can first compute the acceleration vector just by dividing by the mass (ascalar value that is kept as a doubl e value in an instance variable) and then compute the change in velocity by adding to it the amount this vector changes over thetime interval (in the same wayas we used the velocityto change the position). Thislaw immediately translates to the followingcode for updating the position and velocity of a body due to a given force vector f and amount of time dt:

Vector a = f.times(l/mass);v = v.plus(a.times(dt));r = r.plus(v.times(dt));

This code appears in the move() instance method in Body, to adjust its values toreflect the consequences of that force being applied for that amount of time: thebody moves and its velocity changes.This calculation assumes that the accelerationis constant during the time interval.

459

Forces among bodies. The computation of the force imposed by one body on another is encapsulated in the instancemethod forceFromO in Body, which takes a Body object asargument and returns a Vector. Newton's law of universalgravitation is the basis for the calculation:it says that the magnitude of the gravitational force between two bodies is givenby the product of their masses divided by the square of thedistance between them (scaled by the gravitational constantG,which is 6.67 x 1011 N m2/ kg2) and that the direction ofthe force is the line between the two particles. This law translates to the following code for computing a. forceFrom(b):

double G = 6.67e-ll;Vector delta = a.r.minus(b.r);double dist = delta.magnitudeO;double F = (G * a.mass * b.mass) / (dist * dist);return delta.directi on().times(F);

The magnitude of the force vector is the double value F, and the direction of theforce vector is the same as the direction of the difference vector between the two

body's positions. The force vector is the product of magnitude and direction.

unit vector magnitude offorce is

Forcefrom one body to another


IB

Si

il

.••••f 'J

i

Program 3.4.1 Gravitational body

f

dt

forceon thisbody

time increment

acceleration

public class Body{

private Vector r;private Vector v;private final double mass;

public Body(Vector rO, Vector vO, double mO){ r = rO; v = vO; mass = mO; }

public void move(Vector f, double dt){ // Update position and velocity.

Vector a = f.times(1/mass);v = v.plus(a.times(dt));r = r.plus(v.times(dt));

}

public Vector forceFrom(Body b){ // Compute force on this body from b.

Body a = this;double G = 6.67e-ll;Vector delta = a.r.minus(b.r);double dist = delta.magnitudeO;double F = (G * a.mass * b.mass)

/ (dist * dist);retu rn delta.di recti on().ti mes(F);

}

"^^^^^^^P^^^^^s^

a

b

G

delta

dist

F

public void draw()

{StdDraw.setPenRadius(0.025);StdDraw.poi nt(r.cartesi an(0), r.cartesi an(1));

}

thisbody

anotherbody

gravitational constant

vectorfrom b to a

distancefrom b to a

magnitude offorce

Thisdata typeprovides theoperations thatwe needto simulate the motion ofphysicalbodiessuch asplanetsoratomicparticles. It is a mutable type whose instance variables are theposition andvelocity of thebody, which change in the move() method in response toexternalforces(thebody's mass is not mutable). The force From () method returns aforcevector.


Universe data type. Uni verse (Program3.4.2) is a data type that implementsthefollowingAPI:

public class Universe

UniverseO

void increaseTime(double dt)

void draw()

APIfor a universe {see Program 3.4.2)

simulate thepassing of dt seconds

draw the universe

Its data-type values define a universe (its size, number of bodies, and an array ofbodies) and two data-type operations: increaseTi me (), which adjusts the positions (and velocities) of all ofthe bodies, and draw(), which draws all of the bodies.The key to the N-body simulation is the implementation of increaseTi me () inUniverse. The first part of the computation is a double loop that computes theforcevector that describesthe gravitationalforceof eachbody on each other body.It applies the principle of superposition^ which saysthat we can add together the force vectors affectingabody to get a single vector representing all the forces.After it has computed all of the forces, it calls themove() operation for each body to apply the computed force for a fixed time quantum.

% more 2body.txt

2

5.0el0

O.OeOO 4.5el0 1.0e04 0.

O.OeOO -4.5el0 -1.0e04 0.

% more 3body.txt

3

1.25ell

O.OeOO O.OeOO 0.05e04 0.

O.OeOO 4.5el0 3.0e04 0.

O.OeOO -4.5el0 -3.0e04 0.

% more 4body.txt

E— NI 5.0el0|^— radius-3.5elO O.OeOO O.OeOO j 1.4e03|3.0e28

-l.OelO O.OeOO[0T0e00~l.OelO O.OeOO 0.OeOO

I 3.5elO O.OeOOl0.OeOO

velocity

OeOO

OeOO

OeOO

OeOO

OeOO

461

5e30

5e30

97e24

989e30

989e30

\

Vile format. As usual, we use a data-driven designwith input taken from standard input. The constructor reads the universe parameters and body descriptions from a filethat contains the following information:

• The number of bodies

• The radius of the universe

• The position, velocity, and mass of eachbodyAs usual, for consistency, all measurements are instandard SI units (recall also that the gravitationalconstant G appears in our code). With this definedfile format, the code for our Uni verse constructor isstraightforward.

1.4e04|3.0e281.4e04 3.0e28

1.4e03 3.0e28

tposition

Universe file format examples


public UniverseO{

N = Stdln.readlntO;radius = Stdln.readDoubleO;StdDraw.setXscale(-radi us, +radi us);StdDraw.setYscale(-radius, +radius);orbs = new Body[N];for (int i =0; i < N; i++){

double rx = Stdln.readDoubleO;double ry = Stdln.readDoubleO;doubled position = { rx, ry };double vx = Stdln.readDoubleO;double vy = Stdln.readDoubleO;doubled velocity = { vx, vy };double mass = Stdln.readDoubleO;Vector r = new Vector(position);Vector v = new Vector(velocity);orbs[i] = new Body(r, v, mass);

}}

Each Body is described by fivedoubl e values:the x and y coordinates ofits position,the x and y components of its initial velocity, and its mass.

To summarize, wehavein the test client mai n() in Uni verse a data-driven programthat simulates the motion of N bodies mutually attracted by gravity.The constructor creates an array of N Body objects, reading each body's initial position, initialvelocity, and mass from standard input. The increaseTi me () method calculatesthe mutual force on the bodies and uses that information to update the acceleration, velocity,and position of each body after a time quantum dt. The main() testclient invokes the constructor, then stays in a loop calling increaseTi me () anddraw() to simulate motion.

Youwill find on the booksite a variety of files that define "universes" of allsorts, and you are encouraged to run Universe and observe their motion. Whenyou view the motion for even a small number of bodies, you will understand whyNewton had trouble deriving the equations that define their paths. The images onthe chapter openings for Chapters 2, 3, and 4 of this book show the result of running Uni verse for the 2-body, 3-body, and 4-body examples in the data filesshownhere. The 2-body example is a mutually orbiting pair, the 3-body example is a cha-


Program 3.4.2 N-hody simulation

public class Universe{

private final double radius;private final int N;private final Body[] orbs;

public UniverseO{ /* See text. */ }

public void increaseTime(double dt){

Vector[] f = new Vector[N];for (int i = 0; i < N; i++)

f[i] = new Vector(new double[2]);for (int i = 0; i < N; i++)

for (int j = 0; j < N; j++)if (i != j)

f[i] = f[i].plus(orbs[i].forceFrom(orbs[j]));for (int i = 0; i < N; i++)

orbs[i].move(f[i], dt);}

radius

N

orbs[]

463

radiusof universe

number of bodies

arrayof bodies

% java Universe 20000 < 3body.txt

880 steps

public void draw(){

for (int i = 0; i < N; i++)orbs[i].draw();

}


Universe newton = new UniverseO;double dt = Double.parseDouble(args[0]);while (true) ^^^^^^^^^^^^^^^^^^^s^^^

{StdDraw.clear();newton.increaseTime(dt);newton.draw();StdDraw.show(10);

}}

This data-driven program simulates motion in the universe defined by the standard inputstream, increasing timeat the rate specified on thecommand line.

I

mm.


otic situation with a moon jumping between two orbiting planets, and the 4-bodyexample is a relativelysimple situation where two pairs of mutually orbiting bodiesare slowlyrotating. The static images on these pages are made by modifying Universe and Body to draw the bodies in white, and then black on a gray background,as in BouncingBal1 (Program 1.5.6): the dynamic images that you get when yourun Uni verse as it stands givea realistic feeling of the bodies orbiting one another,which is difficult to discern in the fixed pictures. When you run Universe on anexample with a large number of bodies, youcan appreciate why simulation is such an planetary scaleimportant tool for scientists trying to un- %more 2bodv-txtderstand a complex problem. The N-body Qel0simulation model is remarkably versatile, as 0.Oeoo 4.5eio l. 0e04 o.Oeoo l. 5e30you will see if you experiment with some of O.OeOO -4.5eio -i.0e04 O.OeOO i.5e30these files. , , .

subatomic scale

You will certainly be tempted to design 0/ ,. . _.7 r ° % more 2bodyTiny.txt

your own universe (see Exercise 3.4.7). The 2biggest challenge in creating a data file is ap- 5.Oe-iopropriately scaling the numbers so that the °•0e0° 4.5e-io l. 0e-i6 o.Oeoo l. 5e-30radius of the universe, time scale, and the °-0e00 -4-5e"10 -1"06-16 °-0e00 1-5e"30mass and velocity of the bodies lead to interesting behavior. You can study the motion of planets rotating around a sun orsubatomic particles interacting with one another, but you will have no luck studying the interaction of a planet with a subatomic particle. When you work with yourown data, you are likely to have some bodies that will fly off to infinity and someothers that will be sucked into others, but enjoy!

Our purpose in presenting this example is to illustrate the utility ofdata types,not present simulation code for production use. There are many issues that scientists have to deal with when using this approach to study natural phenomena. Thefirst is accuracy: it is common for inaccuracies in the calculations to accumulate topresent dramatic effects in the simulation that would not be observed in nature.For example, our code takes no special action when bodies collide. The second isefficiency: the move() method in Universe takes time proportional to N2 and istherefore not usable for huge numbers of bodies. As with genomics, addressingscientific problems related to the N-body problem now involvesnot just knowledgeof the original problem domain, but also understanding core issues that computerscientists have been studying since the early days of computation.


For simplicity,we are working with a two-dimensional universe, which is realistic onlywhen weare consideringbodies in motion on a plane. But an important implicationof basing the implementation of Body on Vector is that aclient could use three-dimensional vectors to simulate the

motion of moving balls in three dimensions (actually, anynumber of dimensions) without changing the code at all!The draw() method projects the position onto the planedefined by the first two dimensions.

The test client in Universe is just one possibility:wecan use the same basic model in all sorts of other situations

(for example, involving different kinds of interactionsamong the bodies). One such possibility is to observe andmeasure the current motion of some existing bodies andthen run the simulation backwards! That is one method

that astrophysicists use to try to understand the origins ofthe universe. In science,we try to understand the past andto predict the future; with a good simulation, we can doboth.

465

java Universe 25000 < 4body.txt

100 steps

500 steps

1000 steps

3000 steps

Simulating a 4-body universe


Q. The Universe API is certainly small. Why not just implement that code in amai n() test client for Body?

A. Well, our design is an expression of what most people believe about the universe: it was created, and then time moves on. It clarifies the code and allows for

maximum flexibility in simulating what goes on in the universe.

Q. Why is forceFrom() an instance method? Wouldn't it be better for it to be astatic method that takes two Body objects as arguments?

A. Yes, implementing forceFrom() as an instance method is one of several possible alternatives, and having a static method that takes two Body objects as arguments is certainly a reasonable choice. Some programmers prefer to completelyavoid static methods in data-type implementations; another option is to maintainthe force acting on each Body as an instance variable. Our choice is a compromisebetween these two.


3.4.1 Write an object-oriented version of BouncingBall (Program 1.5.6). Include a constructor that starts each ball moving a random direction at a randomvelocity (within reasonable limits) and a test client that takes an integer Nfrom thecommand line and simulates the motion of Nbouncing balls.

3.4.2 Write an object-oriented version of Percol ati on (Program 2.4.5). Thinkcarefullyabout the design before you begin, and be prepared to defend your designdecisions.

3.4.3 What happens in a universe where Newton's second law does not apply?This situation would correspond to forceToO in Body always returning the zerovector.

3.4.4 Create a data type Uni verse3D to model three-dimensional universes. Develop a data file to simulate the motion of the planets in our solar system aroundthe sun.

3.4.5 Modify Universe so that its constructor takes an In object and a Drawobject as arguments. Write a test client that simulates the motion of two differentuniverses (defined by two different files and appearing in two different Draw windows). Youalso need to modify the draw() method in Body.

3.4.6 Implement a class RandomBody that initializes its instance variables with(carefully chosen) random values instead of using a constructor and a client Ran-domUni verse that takes a single argument AT from the command line and simulatesmotion in a random universe with N bodies.

467


3.4.7 New universe. Design a new universe with interesting properties and simulate its motion with Uni verse. This exerciseis truly an opportunity to be creative!

3.4 Case Study: N-Body Simulation 469

Algorithms and Data Structures

4.1 Performance 472

4.2 Sorting and Searching 5104.3 Stacks and Queues 550

4.4 Symbol Tables 608

4.5 Case Study: Small World 650

In this chapter, weDiscuss the fundamental data types that are essentialbuildingblocks for a broad variety of applications. Thischapter is a guide to usingthem,

whether youchoose to useJava libraryimplementations or choose to develop yourown variations based on the code givenhere.

Objects can contain references to other objects, so we can build structuresknown as linked structures, which can be arbitrarily complex. With linked structures and arrays, we can build data structures to organize information in such away that we can efficiently process it with associated algorithms. In a data type,weusethe setof values to build data structures and the methodsthat operateon thosevalues to implement algorithms.

The algorithmsand data structuresthat weconsider in this chapter introducea body of knowledge developed overthe past 50years that constitutes the basisforthe efficient use of computers for a broad variety of applications. From N-bodysimulation problems in physics to geneticsequencing problems in bioinformatics,the basic methods we describe have become essential in scientific research; fromdatabase systemsto search engines,these methods are the foundation of commercial computing. As the scope of computing applications continues to expand, sogrows the impact of these basic methods.

Algorithms and data structures themselves are valid subjects of scientificstudy. Accordingly, we begin by describing a scientific approach for analyzing theperformanceof algorithms, whichweusethroughout the chapter to study the performance characteristics of our implementations.

471


4.1 Performance

In this section, you will learn to respect a principle that is succinctly expressed inyet another mantra that should live with you wheneveryou program: Pay attentiontothe cost. Ifyou become an engineer, thatwillbeyourjob;ifyoubecomeabiologist 4JJ 3.sumproblem ; 475or a physicist, the cost will dictate which 4<L2 Validating adoubling hypothesis. .477scientific problems you can address; if n . +7. ..v 7 y Programs in thissectionyou are in business or become an economist, this principle needs no defense;andif you become a software developer, the costwilldictatewhether the software thatyou build willbe useful to any of your clients.

Tostudy the cost of running them, westudy our programs themselves via thescientific method, the commonly accepted body of techniques universally used byscientiststo developknowledge about the natural world.Wealso apply mathematicalanalysis to derive concise models of the cost.

What features of the natural world are we studying? In most situations, we areinterested in one fundamental characteristic: time. On each occasion that we run

a program, we are performing an experiment involving the natural world, puttinga complex systemof electronic circuitry through series of state changes involvinga huge number of discrete events that we are confident will eventually stabilizeto a state with results that we want to interpret. Although developed in the abstract world of Java programming, these events most definitely are happening inthe natural world. What will be the elapsed time until we see the result? It makesa great deal of difference to us whether that time is a millisecond, a second, a day,or a week, and therefore we want to learn, through the scientific method, how toproperly control the situation, just as when we launch a rocket, build a bridge, orsmash an atom.

On the one hand, modern programs and programming environments arecomplex; on the other hand, they are developed from a simple (but powerful) setof abstractions. It is a small miracle that a program produces the same result eachtime we run it. To predict the time required, we take advantage of the relative simplicityof the supporting infrastructure that we use to build programs.You may besurprised at the ease with which you can develop cost estimates for many of theprograms that you write.

4.1 Performance

Scientific method The following five-step approach briefly summarizes thescientific method.

• Observe some feature of the natural world.

• Hypothesize a model that is consistent with the observations.• Predict events using the hypothesis.• Verify the predictions by making further observations.• Validate by repeating until the hypothesis and observations agree.

One of the key tenets of the scientific method is that the experiments we designmust be reproducible, so that otherscan convince themselves of the validity of thehypothesis. In addition, the hypotheses weformulate must befalsifiable, so that wecan know for sure when a hypothesis iswrong (and thus needsrevision).

Observations Ourfirst challenge isto make quantitative measurements of therunning time of our programs. Although measuring the exact running time of ourprogram is difficult, usuallywe are happy with approximateestimates. There are anumber of tools available to help us obtain such approximations. Perhaps the simplest is a physical stopwatchor the Stopwatch (see Program3.2.2) data type.Wecan simply run a program on various inputs, measuring the amount of time to process each input.

Our firstqualitative observationabout most programs is that there is a problem size that characterizesthe difficulty of the computational task. Normally, theproblem size is either the sizeof the input or the valueof a command-line argument. Intuitively, the runningtime should increase with the problem size, but thequestion of how much it increases naturally arises every time we develop and run a program.

Another qualitative observation for many programs is that the running time is relatively insensitiveto the input itself; it depends primarily on the problemsize. If this relationship does not hold, we need to run more experiments to betterunderstand, and perhaps better control, the running time's sensitivity to the input.Since this relationshipdoesoftenhold,wefocus nowon the goalof better quantifying the correspondencebetween problem sizeand running time.

473

% Java ThreeSum < lKints.txt

tick tick tick

0

% Java ThreeSum < 2Kints.txt

>tick tick tick tick tick tick

tick tick tick tick tick tick



391930676 -763182495 371251819

-326747290 802431422 -475684132

Observing therunning timeofa program

474 Algorithms and Data Structures

As a concrete example, westartwithTh reeSum (Program 4.1.1), which countsthe number of triples in a setof N numbers that sum to 0.Thiscomputationmayseem contrived to you, but it isdeeply related to numerous fundamental computationaltasks, particularly those found in computational geometry, so it isa problemworthy of careful study. What is the relationship between the problem size N andrunning time for ThreeSum?

Hypotheses In the early days of computer science, Donald Knuth showed that,despite allof the complicating factors in understanding the running times of ourprograms, it ispossible in principle to create accurate models that canhelp us predictprecisely how longa particular program will take. Proper analysis of thissortinvolves:

• detailed understanding of the program• detailed understanding of the systemand the computer• advanced tools of mathematical analysis

and so is best left for experts. But every programmer needs to knowback-of-the-envelope performance estimates. Fortunately, we canoftenacquire suchknowledgebyusing a combination of empirical observations and a small setof mathematicaltools.

Doubling hypotheses. For a great many programs, we can quickly formulate ahypothesis for the following question: What isthe effect on the running time ofdoubling the size of the input? For clarity, we refer to this hypothesis as a doubling hypothesis. Perhaps the easiest way to payattention to the cost is to askyourself thisquestion about your programs during development and also as you use them inpractical applications. Next, we describe how to develop answers via the scientificmethod.

Empirical analysis. Onesimple way to develop a doubling hypothesis isto doublethe size of the input and observe the effect on the running time. For example, Dou-blingTest (Program 4.1.2) generates a sequence of random input arrays forThreeSum, doubling the array size at each step, and prints the ratio of runningtimes of ThreeSum. count () for eachinput overthe previous (whichwasone-halfthe size). If you run this program, you will find yourself caught in a prediction-verification cycle: It prints several linesveryquickly, but then beginsto slowdown.Eachtime it prints a line,you find yourselfwondering how long it will be until it

4.1 Performance 475

f

I•!v.,:<

Si

public class ThreeSum{

public static void printAll(int[] a){ /* See Exercise 4.1.1. V }

public static int count(int[] a){ // Count triples that sum to 0.

int N = a.length;int cnt = 0;for (int i = 0; i < N; i++)

for (int j = i+1; j < N; j++)for (int k = j+1; k < N; k++)

if (a[i] + a[j] + a[k] == 0)cnt++;

return cnt;

}

public static void main(String[] args){ // Count triples that sum to 0 in input.

int[] a = StdArraylO.readlntlDO;int cnt = count(a);StdOut.println(cnt);if (cnt < 10) printAll(a);

}

N

a[]

cnt

number of inputs

integerinputs

number of triplesthat sum to 0

The count () method counts the triples of integers in a[] whose sum is 0. The test client invokes count () for the integers onstandard input and prints the triples if the count is low. Thefile IKints. txt contains 1,024 random values from the i nt data type. Such afile isnotlikelyto havesuch a triple (seeExercise 4.1.28).

% Java ThreeSum < 8ints.txt

30 -30 0

30 -20 -10

-30 -10 40

-10 0 10

% Java ThreeSum < lKints.txt0

6

^m^^^^mm^^^^mmm^^^^mmm


prints the next line. Checking the stopwatch as the program runs, it is easyto predict that the elapsed time increases by about a factorof eight to print each line. This prediction is verifiedby the Stopwatch measurements that the programprints, and leads immediately to the hypothesis thatthe running time increases by a factor of eight whenthe input sizedoubles.Wemight also plot the runningtimes, either on a standard plot (left), which clearlyshows that the rate of increase of the running timeincreases with input size, or on a log-log plot. In thecaseof ThreeSum, the log-logplot (below) is a straightlinewith slope3,which clearlysuggests the hypothesisthat the running time satisfies apower law of the formcN3 (see Exercise 4.1.30).

Standard plot

Mathematical analysis. Knuth's basic insight on building a mathematical modelto describe the running time of a program is simple: the total running time is determined by two primary factors:

• The cost of executing each statement• The frequency of execution of each statement

The former is a property of the system, and the latter is aproperty of the algorithm. If we know both for all instructions in the program, wecan multiplythem together and sumfor all instructions in the program to get the running time.

The primary challenge is to determine the frequencyofexecution of the statements. Some statements are easy to analyze: for example, the statement that sets cnt to 0 in Three-Sum, count () is executed only once. Others require higher-levelreasoning: for example, the if statement in ThreeSum.count() is executed preciselyN(N-l)(N-2)/6 times (thatis preciselythe number of ways to pick three different numbers from the input array—seeExercise 4.1.4).

Frequencyanalyses of this sort can lead to complicatedand lengthy mathematical expressions. To substantially simplify matters in the mathematical analysis, we develop simpler approximate expressionsin two ways. First,wework with Log-logplot

4.1 Performance 477

?S8

w

Program 4.1.2 Validating a doubling hypothesis

public class DoublingTest{

public static double timeTrial(int N){ // Compute time to solve a random instance of size

int[] a = new int[N];for (int i = 0; i < N; i++)

a[i] = StdRandom.uniform(2000000) - 1000000;Stopwatch s = new Stopwatch();int cnt = ThreeSum.count(a);return s.elapsedTime();

}

public static void main(String[] args){ // Print table of doubling ratios.

double prev = timeTrial(256);for (int N = 512; true; N += N){ // Print doubling ratio for problem size

double curr = timeTrial(N);Std0ut.printf("%7d %4.2f\nM, N, curr / prev);prev = curr;

}}

This program prints a table showing how doubling the problem sizeaffects the running timeofTh reeSum.count () forproblem sizes starting at 256 anddoublingfor each rowof thetable.These experiments lead immediately to the hypothesis that the running time increases by afactor ofeight when theinput size doubles. When you run the program, note carefully thattheelapsed time between lines printed increases by afactor ofeightforeach line, at once verifyingthehypothesis.

% Java Doubling Iest512 6.48

1024 8.30

2048 7.75

4096 8.00

8192 8.05

'^^^^^^^^^^^^^^^P^^iS^^^^^^^


public class ThreeSum 117. r ^ . 1{ the leading term of mathematical ex-

pubiic static int count(int[] a) pressions by using a mathematicaldevice known as the tilde notation.

We write ~/(N) to represent anyquantity that, when divided by/(N),approaches 1 as AT grows. We alsowrite g(N)~f(N) to indicate thatg(N) /f(N) approaches 1 as N grows.With this notation, we can ignorecomplicated parts of an expressionthat represent small values. For example, the i f statement in ThreeSumis executed ~N3/6 times because

N(N-l)(N-2)/6 = N3/6 - N2/2 +N/3, which certainly,when divided byN3/6, approaches 1 as N grows. Thisnotation is useful when the terms af

ter the leading term are relatively insignificant (for example,when JV = 1000, this assumption amounts to saying that—N2/2 + N/3 « —499,667 is relatively insignificant by comparison with N3/6 »166,666,667, which it is). Second, we focus on the instructions that are executedmost frequently, sometimes referred to as the inner loop of the program. In thisprogram it is reasonable to assume that the time devoted to the instructions outsidethe inner loop is relativelyinsignificant.

The key point in analyzingthe running time of a program is this: for a greatmany programs, the running time satisfies the relationship

T(N) - cf(N)where c is a constant and/(N) a function knownas the order of growth of the running time. Fortypical programs,/(N) is a function such as log N,N, N log N, N2, or N3, as you will soon see (customarily, we express order-of-growth functionswithout any constant coefficient). When/(N) isa power of N, as is often the case, this assumption is equivalent to saying that the running timesatisfies a power law. In the case ofThreeSum,it is

inner

loop

}

int N = a.length;int cnt = 0;

for (int i = 0; i < N; i++)

-i

for (int j = i+1; j < N; j++) -i— h

\for (int k = j+1; k < N; k++)

k| if (a[ij + a[;j] + a[k] == 0)\--cnt++; ^

\

return cnt; \ depends on input data

•N2/2

•NV6


int[] a = StdArraylO.readlntlDO;int cnt = count(a);

StdOut.println(cnt);

}

Anatomy ofa program's statement execution frequencies

N(N- l)(N-2)/6

166,167,000

1,000

Leading-term approximation

4.1 Performance

a hypothesis already verified by our empirical observations: theorder ofgrowth ofthe running timeof ThreeSum is N3. The value of the constant c depends both onthe cost of executing instructions and on details of the frequency analysis, but wenormally do not need to work out the value, as you will now see.

The order of growth is a simple but powerful model of running time. Forexample, knowing the order of growth typically leads immediately to a doublinghypothesis. In the caseof ThreeSum, knowing that the order of growth is N3 tells usto expect the running time to increase by a factor of eight when we double the sizeof the problem because

T(2N)/T(N) -> c(2N)3/(cN3) = 8

This matches the value resulting from the empirical analysis, thus validating boththe model and the experiments. Study this example carefullyy becauseyou canusethesame method to better understand the performance ofanyprogram thatyou write.

Knuth showed that it is possible to develop an accurate mathematical modelof the running time of any program, and many expertshavedevoted much effort todeveloping such models. But you do not need such a detailed model to understandthe performance of your programs: it is typically safe to ignore the cost of the instructions outside the inner loop (because that cost is negligibleby comparison tothe cost of the instruction in the inner loop) and not necessaryto know the valueof the constant in the running-time approximation (because it cancels out whenyou use a doubling hypothesis).

number of time per instructioninstructions in seconds

frequency total time

6

4

4

10

2xl0-9 N3/6 - N2I2 + N/3 (2N3 - 6N2 + 4N) x 10"9

3xl0"9 NV2-N/2 (6N2 + 6N)xlO"9

3xl0"9 N (12N)xlO"9

lxlO"9 1 lOxlO"9

grand total: (2 N3 + 22 N + 10) X 10 "9

tilde notation (2 N3) X 10 ~~9

order ofgrowth N3

Analyzingtherunningtimeof a program (example)

479


These approximations are significantbecause they relate the abstract world ofa Javaprogram to the real world of a computer running it. The approximations aresuch that characteristics of the particular machine that you are using do not play asignificant role in the models—we separate the algorithm from the system. The order of growth of the running time of ThreeSum is N3 does not depend on whetherit is implemented in Java, or whether it is running on your laptop, someone else'scellphone, or a supercomputer; it depends primarily on the fact that it examinesall the triples. The properties of the computer and the system are all summarizedin various assumptions about the relationship between program statements andmachine instructions, and in the actual running times that we observe as the basisfor the doubling hypothesis.The algorithm that you are using determines the orderof growth. This separation is a powerful concept because it allows us to developknowledge about the performance of algorithms and then apply that knowledgetoany computer. In fact,much of the knowledge about the performance of classic algorithms was developeddecades ago,but that knowledge is still relevant to today'scomputers.

Empirical and mathematical analyses like those we have described constitute a mod

el (an explanation of what is going on) that might be formalized by listing all ofthe assumptions mentioned (eachinstruction takesthe same amount of time eachtime it is executed,running time has the givenform, and so forth). Not many programs are worthy of a detailedmodel,but you need to have an idea of the runningtime that you might expect for every program that you write. Payattention to thecost Formulating a doubling hypothesis—through empirical studies, mathematical analysis, or (preferably) both—is a good wayto start. This information aboutperformance is extremelyuseful, and you will soon find yourself formulating andvalidatinghypotheseseverytime you run a program. Indeed, doing so is a good useof your time while you wait for your program to finish!

Order of growth classifications We usejust a few structural primitives (statements, conditionals, loops, and method calls) to build Javaprograms, so very oftenthe order of growth of our programs is one of just a few functions of the problemsize,summarized in the table on the next page.These functions immediately lead toa doubling hypothesis, which we can verifyby running the programs. Indeed, youhave been running programs that exhibit these orders of growth, as you can see inthe following brief discussions.

4.1 Performance

Constant. A program whose running time's order of growth is constant executesafixednumber of statements to finish its job; consequently its running time does notdepend on the problem size.Our first severalprograms in Chapter 1—such as Hel-loWorld (Program 1.1.1) and LeapYear (Program 1.2.4)—fall into this classification. They each execute several statements just once. All of Java's operations onprimitive types take constant time, as do Java's Math library functions. Note that wedo not specify the size of the constant. For example, the constant for Math. tan () issomewhat larger than for Math. abs ().

481

Logarithmic. A program whose running time'sorder of growth is logarithmic is barely slower thana constant-time program. The classic example of aprogram whose running time is logarithmic in theproblem size is looking up an entry in an orderedtable, which we consider in the next section (seeBinarySearch, in Program 4.2.3). The base of thelogarithm is not relevant with respect to the order ofgrowth (since all logarithms with a constant base arerelated by a constant factor), so we use log JV whenreferring to order of growth. Occasionally, we writemore precise formulas using lg JV (base 2, or binarylog) or In JV (base e> or natural log) becausetheybotharise naturally when studying computer programs.For example, lgJV, rounded up, is the number of bitsin the binary representation of JV, and In N arises inthe analysis of binary search trees (see Section 4.4).

order ofgrowth

description function

factorfordoubling

hypothesis

constant 1

logarithmic log JV

linear JV

linearithmic JV log JV

quadratic

cubic

exponential

JV2

N3

2N

1

Commonly encountered growth functions

Linear. Programs that spend a constant amount of time processing each pieceof input data, or that are based on a single for loop, are quite common. The order of growth of such a program is said to be linear—its running time is directlyproportional to the problem size. Average (Program 1.5.3), which computes theaverage of the numbers on standard input, is prototypical, as is our code to shufflethe entries in an array in Section 1.4. Filters such as PlotFilter (Program 1.5.5)also fall into this classification, as do the various image-processing filters that weconsidered in Section 3.2, which perform a constant number of arithmetic operations per input pixel.

482

time

I1024T

512T

64T -

8T -

4T •

2T •

T


Linearithmic. Weuse the term linearithmic to describeprograms whose runningtime for a problem of size JV has order of growth JV log N. Again, the base of thelogarithm is not relevant. For example, CouponCollector (Program 1.4.2) is linearithmic. The prototypical example is mergesort (see Program 4.2.6). Several important problems have natural solutions that are quadratic but clever algorithmsthat are linearithmic. Such algorithms (including mergesort) are critically important in practice because they enable us to address problem sizes far larger thancould be addressed with quadratic solutions. In the next section, we consider a

general design technique for developinglinearithmic algorithms.

Quadratic. A typical program whoserunning time has order of growth JV2has two nested for loops, used for somecalculation involving all pairs of JV elements. The force update double loop inNBody (Program 3.4.2) is a prototype ofthe programs in this classification, as isthe elementary sorting algorithm Inser-tion (Program 4.2.4).

Cubic. Our example for this section,ThreeSum, is cubic (its running time hasorder of growth JV3) because it has threenested for loops, to process all triples ofJV elements. The running time of matrixmultiplication, as implemented in Section 1.4 has order of growth M3 to mul

tiply two M-by-M matrices, so the basic matrix multiplication algorithm is oftenconsidered to be cubic. However,the sizeof the input (the number of entries in thematrices) is proportional to JV = M2, so the algorithm is best classified as JV3/2, notcubic.

—\ 1 1 r~

IK 2K 4K 8K

Orders ofgrowth (log-log plot)

constant

n r

1024K

Exponential. As discussed in Section 2.3, both TowersOfHanoi (Program 2.3.2)and GrayCode (Program 2.3.3) have running times proportional to 2N because theyprocess all subsets of JV elements. Generally, we use the term "exponential" to refer

4.1 Performance 483

to algorithmswhose order of growth is bN for anyconstant b> 1,even though different valuesof blead to vastlydifferentrunning times.Exponentialalgorithms areextremely slow—you will never run one of them for a largeproblem. They play acritical role in the theory of algorithms because there exists a large class of problems for which it seems that an exponential algorithm is the best possible choice.

Theseclassifications are the most common, but certainlynot a complete set. Indeed,the detailed analysis of algorithmscan require the fullgamut of mathematical toolsthat have been developed over the centuries. Understanding the running time ofprograms such as Factor (Program 1.3.9), PrimeSieve (Program 1.4.3) and Eu-cl i d (Program 2.3.1), requires fundamental results from number theory. Standardalgorithms like BST (Program 4.4.3) require careful mathematical analysis.Newton(Program 2.1.1) and Markov (Program 1.6.3)are prototypes for numerical computation: their running time is dependent on the rate of convergence of a computation to a desired numerical result. Simulations such as Gambler (Program 1.3.8)and its variants are of interest preciselybecause detailed mathematical models arenot alwaysavailable.

But a great many of the programs that you will write have straightforwardperformance characteristics that can be accurately described by one of the ordersof growth that we have considered. Accordingly, we can usually work with simplehigher-level hypotheses, such as theorder ofgrowth of therunning timeof mergesortis linearithmic. For economy, we abbreviate such a statement to just say mergesortis linearithmic. Most of our hypotheses about cost are of this form, or of the formmergesort isfaster than insertion sort. Again,a notable feature of such hypotheses isthat they are statements about algorithms, not just about programs.

Predictions You can always try to learn the running time of a program by simply running it, but that might be a poor way to proceed when the problem sizeis large. In that case, it is analogous to trying to learn where a rocket will land bylaunching it, how destructive a bomb willbe by igniting it, or whether a bridge willstand by building it.

Knowing the order ofgrowth of the running time allowsus to make decisionsabout addressing large problems so that we can investwhatever resources we haveto deal with the specific problems that we actually need to solve.We typically usethe results of verifiedhypotheses about the order of growth of the running time ofprograms in one of the following four ways.


Estimating thefeasibility ofsolving large problems. To payattention to the cost,you need to answer this basicquestion for everyprogram that you write: Will thisprogram beable toprocess this input data in a reasonable amount of time? For example, a cubic algorithm that runs in a couple of seconds for a problem of size JVwill require a few weeks for a problem of size 100JV because it will be a million(1003) times slower, and a couple of millionseconds is a few weeks. If that is the size of

the problem that you need to solve, you haveto find a better method. Knowing the orderof growth of the running time of an algorithm provides precisely the informationthat you need to understand limitations onthe size of the problems that you can solve.Developing such understanding is the mostimportant reason to study performance.Without it, you are likely have no idea howmuch time a program will consume; with it,you can make a back-of-the-envelope calculation to estimate costs and proceed accordingly.

order ofgrowthpredicted running time if

problem size is increased byafactorof 100

linear a few minutes

linearithmic a few minutes

quadratic several hours

cubic a few weeks

exponential forever

Effect of increasing problem sizefor a program thatrunsfor afew seconds

Estimating the value ofusing afaster computer. To payattentionto the cost, youalso maybe facedwith this basic question, periodically: Howmuchfaster canI solvetheproblem if I get a faster computer? Again, knowing the order of growth of therunning time provides precisely the information that you need. A famous rule ofthumb known as Moore's Law implies that you can expect to have a computer withabout double the speed and double the memory 18 months from now, or a computer with about 10 times the speed and 10 times the memory in about 5 years. Itis natural to think that if you buy a new computer that is 10 times faster and has 10times more memory than your old one, you can solve a problem 10 times the size,but that is not the case for quadratic or cubic algorithms. Whether it is an investment banker running daily financial models or a scientist running a program toanalyze experimentaldata or an engineerrunning simulations to test a design,it isnot unusual for people to regularly run programs that take several hours to complete. Suppose that you are using a program whose running time is cubic, and thenbuy a new computer that is 10 times faster with 10 times more memory, not just

4.1 Performance 485

because you need a new computer, but because you face problems that are 10 timeslarger.The rude awakening is that it will take a severalweeks to get results, becausethe larger problems would be a thousand times slower on the old computer andimproved by only a factor of 10on the new computer.This kind of situation is theprimary reason that linear and linearithmic algorithms are so valuable becausewith such an algorithm and a new computer that is 10 times faster with 10 timesmore memory than an old computer, you can solve a problem that is 10 timeslarger than could be solved by the old computer in the same amount of time. Inother words, you cannot keep pace with Moore's Lawif you are using a quadraticor a cubic algorithm.

Processing multiple instances. For fast algorithms,we often think in terms of multiple problem instances. For example, consider the effect of Moore's law ona company that provides web services, say, at the rateof a million problems of size JV every few seconds. Atwhat rate can problems that are 10 times larger be handled with a computer that is 10 times faster (or with 10times as many computers)? If the algorithm is linear,the rate stays the same; remarkably, if the algorithm islogarithmic, the rate can be increased by a factor of 10,even though problems are 10 times larger. For example, a company that can handle 10 million requests ofsize IONper second (using a logarithmic algorithm) islikely to do much better than one competitor that canhandle only 1 million requests of size 10JV per secondand another competitor that can handle only 10 millionrequests of size JV per second.

order ofgrowth

predictedfactorofproblem size

increase if computerspeed is increased by

afactorof 10

linear 10

linearithmic 10

quadratic 3-4

cubic 2-3

exponential 1

Effect of increasing computer speedonproblem size thatcanbesolved in

afixed amountof time

Comparing programs. We are always seeking to improve our programs, and wecan often extend or modify our hypothesesto evaluatethe effectiveness of variousimprovements. With the ability to predict performance, we can make design decisions during the development of an implementation that can guide us towards better, more efficient code. As an example, a novice programmer might have writtenthe nested for loops in ThreeSum as



for (int k = 0; k < N; k++)if (i < j && j < k)

if (a[i] + a[j] + a[k] == 0)cnt++;

so that frequency of execution of the instructions in the inner loop would be exactlyJV3 (instead of approximatelyJV3/6). It is easyto formulate and verifythe hypothesis that ThreeSumis six times as fast as this variant. Note that improvementslike this for code that is notin the inner loop will have little or no effect. More generally, given two algorithms that solvethe same problem, we want to know whichone willsolve our problem using fewer computational resources. In many cases, wecan determine the order of growth of the running times and develop accurate hypotheses about comparative performance. The order of growth is extremely usefulin this process because it allowsus to compare one particular algorithm with wholeclasses of algorithms. For example, once we have a linearithmic algorithm to solvea problem, we become less interested in quadratic or cubic algorithms (even if theyare highly optimized) to solvethe same problem.

Caveats There are many reasons that you might get inconsistent or misleadingresults when trying to analyze program performance in detail. All of them haveto do with the idea that one or more of the basic assumptions underlying our hypotheses might not be quite correct.Wecan developnew hypothesesbased on newassumptions, but the more details that we need to take into account, the more careis required in the analysis.

Instruction time. The assumption that each instruction always takes the sameamount of time isnot always correct.Forexample, most modern computer systemsuse a technique known as caching to organize memory, in which case accessingelements in huge arrays can take much longer if they are not close together in thearray.Youcan observe the effectof cachingfor ThreeSum by letting Doubl i ngTestrun for a while. Afterseeming to converge to 8,the ratio of running timeswilljumpto a larger value for large arraysbecauseof caching.

Nondominant inner loop. The assumption that the inner loop dominates maynot always be correct. The problem size JV might not be sufficiently large to make

4.1 Performance 487

the leading term in the mathematical description of the frequency of execution ofinstructions in the inner loop so much larger than lower-order terms that we canignore them. Some programs have a significantamount of code outside the innerloop that needs to be taken into consideration.

System considerations. Typically, there are many, many things going on in yourcomputer. Javais one application of many competing for resources, and Javaitselfhas many options and controls that significantly affectperformance. Such considerations can interfere with the bedrock principle of the scientific method that experiments should be reproducible, since what is happening at this moment in yourcomputer will never be reproduced again.Whatever elseis going on in your system(that is beyond your control) should inprinciple be negligible.

Too close to call. Often, when we compare two different programs for the sametask, one might be faster in some situations, and slower in others. One or moreof the considerations just mentioned could make the difference. Again, there isa natural tendency among some programmers (and some students) to devote anextreme amount of energy running such horseraces to find the "best" implementation, but such work is best left for experts.

Strong dependence on input values. One of the first assumptions that we madein order to determine the order of growth of the program's running time of a program was that the running time should be relatively insensitiveto the input values.When that is not the case, we may get inconsistent results or be unable to validateour hypotheses. Our running example ThreeSum does not have this problem, butmany of the programs that we write certainly do. We will see several examples ofsuch programs in this chapter. Often, a prime design goal is to eliminate the dependence on input values. If we cannot do so, we need to more carefully model thekind of input to be processed in the problems that we need to solve, which maybe a significant challenge. For example, if we are writing a program to process agenome, how do we know how it will perform on a different genome? But a goodmodel describing the genomes found in nature is precisely what scientists seek,so estimating the running time of our programs on data found in nature actuallyamounts to contributing to that model!


Multipleproblem parameters. We have beenfocusing on measuring performanceasa function of a single parameter,generally the valueof a command-line argumentor the size of the input. However, it is not unusual to have several parameters. Forexample, the percolation probability estimation method Esti mate. eval () in Section 2.4 has two parameters: JV (the sizeof the grid) and T (the number of trials).In such cases, we treat the parameters separately, holding one fixed whileanalyzingthe other. In the caseof Esti mate. eval (), the order of growth of the running timeis TN2, or linear in T and quadratic in JV.

Despiteall these caveats, understanding the order of growth of the running timeof each program is valuable knowledgefor any programmer, and the methods thatwe have described are powerful and broadly applicable. Knuth's insight was thatwe can carry these methods through to the last detail inprinciple to make detailed,accurate predictions. Typical computer systems are extremely complex and closeanalysis is best left for experts, but the same methods are effective for developingapproximate estimates of the running time of any program. A rocket scientist needsto have some idea of whether a test flight will land in the ocean or in a city; a medical researcher needs to know whether a drug trial will kill or cure all the subjects;and any scientist or engineer using a computer program needs to have some idea ofwhether it will run for a second or for a year.

Performance guarantees For some programs, we demand that the runningtime of a program is less than a certain bound, no matter what the input values. Toprovide such performance guarantees, theoreticians take an extremely pessimisticview of the performance of algorithms: what would the running time be in theworst case7.

For example, such a conservativeapproach might be appropriate for the software that runs a nuclear reactor or an air traffic control system or the brakes inyour car. We want to guarantee that such software completes its job within thebounds that we set because the result could be catastrophic if it does not.

Scientists normally do not contemplate the worst case when studying thenatural world: in biology,the worst casemight the extinction of the human race; inphysics, the worst case might be the end of the universe. But the worst case can bea very real concern in computer systems,where the input may be generated by another (potentially malicious) user, rather than by nature. For example, websites thatdo not use algorithms with performance guarantees are subject to denial-of-service

4.1 Performance 489

attacks, where hackers flood them with pathological requests that make them runmuch more slowly than planned.

Performance guarantees are difficult to verifywith the scientific method, because we cannot test a hypothesis such as Mergesort is guaranteed to be linearithmicwithout trying all possible input values,which we cannot do because there arefar too many of them. We might falsify such a hypothesis by providing inputs forwhich mergesort is slow, but how can we prove it to be true? We can do this notwith experimentation, but with mathematical models. In fact, it is often no moredifficult to develop performance guarantees than it is to predict performance. Indeed, it is often the case that the same mathematical model used to prove that aprogram computes the expected results can also provide the performance guarantees that we need.

Often, randomness provides performance guarantees. For example, it is possible, though extraordinarily unlikely, that CouponCol 1ector (Program 1.4.2) willnot terminate, but mathematical analysis provides a way for us to guarantee thatits running time is linearithmic. The guarantee is probabilistic, but the chance thatit is invalid is less than the chance your computer will be simultaneously struck bylightning and hit by a meteor.

It is the task of the algorithm analyst to discoveras much relevant informationabout an algorithm as possible, and it is the task of the applications programmerto apply that knowledge to develop programs that effectively solve the problems athand. For example, if you are using a quadratic algorithm to solve a problem butcan find an algorithm that is guaranteed to be linearithmic, you certainly are welladvised to consider it, because an algorithm that makes the worst caselinearithmicmakes the running time for every case linearithmic or better. On the other hand, it issometimes true that an algorithm that provides worst case performance guaranteeis overly complex, adding unnecessary overhead to protect against a situation thatyou will never encounter. For example, an algorithm that provides a linearithmicguarantee might not be the best one to use, because some other algorithm mightsolveyourproblem in linear time (your input values might not be the worst case).

Ideally,we want algorithms that lead to clear and compact code that providesboth a good guarantee and good performance on input values of interest. Many ofthe classic algorithms that we consider in this chapter are of importance for a broadvariety of applications precisely because they have all of these properties. Usingthese algorithms as models, you can develop good solutions yourself for typicalproblems that you face while programming.


Memory Aswith running time, a program's memory usageconnects directly tothe physicalworld: a substantial amount of your computer's circuitry enablesyourprogram to store values and later retrieve them. The more values you need to havestored at any given instant, the more circuitry you need. Topayattention to thecost,you need to be aware of memory usage.Youprobably are aware of limits on memory usage on your computer (even more so than for time) because you probablyhave paid extra money to get more memory.

Memory usage is well-defined for Java on your computer (every value willrequire precisely the same amount of memory each time that you run your program), but Java is implemented on a very wide range of computational devices,and memory consumption is implementation-dependent. For economy, we use theword typical to signal values that are particularly subject to machine dependencies. Analyzing memory usage is somewhat different from analyzing time usage,primarily because one of Java's most significant features is its memory allocationsystem, which is supposed to relieve you of having to worry about memory. Certainly,you are well advised to take advantage of this feature when appropriate. Still,it is your responsibility to know,at least approximately, when a program's memory

requirements will prevent you from solving a given problem.

type bytes

boolean 1

byte 1

char 2 type. For example, since the Java i nt data type is the set of integer valuesint 4 between -2,147,483,648 and 2,147,483,647, a grand total of 232 differ-

float 4 entvalues> ^ *s reasonable to expect implementations to use 32 bits torepresent i nt values, and similar considerations hold for other primitivetypes. Typical Java implementations use 8-bit bytes, representing eachchar value with 2 bytes (16 bits), each i nt value with 4 bytes (32 bits),

Typical memory each doubl e value with 8bytes (64 bits), and each bool ean value with 1requirementsfor byte (since computers typically access memory one byte at a time). Forprimitive types example, ifyou have 1GB ofmemory onyour computer (about 1billion

bytes), you cannot fit more than about 32 million i nt values or 16 million doubl e values in memory at any one time.

Objects. To determine the memory consumption of an object, weaddthe amountof memory used by each instance variable to the overhead associated with each

long 8

double 8

Primitive types. It is easy to estimate memory usage for simple programs like the ones we considered in Chapter 1: Count up the numberof variables and weight them by the number of bytes according to their

4.1 Performance

object, typically 8 bytes. For example, a Charge (Program 3.2.1) object uses 32bytes (8 bytes of overhead and 8 bytes for each of its three doubl e instance variables).Similarly, a Compl ex object uses24 bytes. Since many programs create millions of Color objects, typical Javaimplementations pack the information neededfor them into 32bits (three bytesfor RGB values and one for transparency).A reference to an object typically uses 4 bytes of memory. When a data type contains areference to an object,wehaveto account separately for the 4bytesfor the referenceand the 8 bytes overhead for each object plus the memory needed for the object'sinstance variables. In particular, a Document(Program 3.3.4) object uses 16bytes (8bytes ofoverhead and 4 bytes each for the references tothe St ri ng and Vector objects) plus the memory needed for the St ri ng and Vector objectsthemselves (which we consider next).

Charge object (Program 3.2.1)


private double rx;private double ry;private double q;

}"

32 bytes

24 bytes

12 bytes

491

String objects. We account for memory in aSt ri ng object in the same wayas for any otherobject. Java's implementation of a String object consumes 24 bytes: a reference to a character array (4 bytes), three i nt values (4 byteseach), and the object overhead (8 bytes). Thefirst i nt value is an offset into the character ar

ray; the second is a count (the string length). Interms of the instance variable names in the figure at right, the string that is represented consists of the characters val [offset] throughval [offset + count - 1]. The third i nt value

in String objects is a hash code that saves re-computation in certain circumstances thatneed not concern us now. In addition to the 24

bytes for the String object, we must accountfor the memory needed for the charactersthemselves,which are in the array.We accountfor this space next.

Complex object (Program 3.2.6)public class Complex{

private double re;private double im;

}"

Color object (Java library)public class Color{

private byte r;private byte g;private byte b;private byte a;

}"

Document object (Program 3.3.4)public class Document{

private String id;private Vector profile;

}"

String object (Java library)public class String{

private char[] val;private int offset;private int count;private int hash;

16 bytes + string+ vector

references

24 bytes + chararray

reference

Typical object memoryrequirements


Arrays. Arrays in Java are implemented as objects, typically with two instancevariables (a pointer to the memory location of the first array element and thelength). For primitive types, an array of N elements requires 16 bytes of header information plus N times the number of bytes needed to store an element. For example, the int array in Sample (Program 1.4.1) uses 4JV +16 bytes, whereas thebool ean arrays in Coupon (Program 1.4.2)usesJV + 16bytes. Note than a bool eanarray consumes one byte of memory per entry (wasting 7 of the 8 bits)—with someextra work, you could get the job done with N/8 bytes (see Exercise 4.1.26).An array of objects is an array of references to the objects, so we need to add the space forthe referencesto the space required for the objects. For example, the array of Chargeobjects in Potenti al (Program 3.1.7) uses 16 (array overhead) plus 4N (references) plus 32N (objects) bytes for a total of 36N +16 bytes.This analysisassumes thatall of the objects are different: it is possiblethat multiple array entries could refer to

Array of int values (Program 1.4.1)int[] perm = new int[N];

16bytes

reference

int

values

Total: 16+ 4N

4N bytes

Array o/doubl e values (Program 2.1.4)

doubl e[] c = new doubl e[N];

16 bytes

Total: 16+ 8N

Array ofpoint charges (Program 3.1.7)

Charge[] a = new Charge[N];for (int k = 0; k < N; k++)

{

a[k] = new Charge(x0, yO, qO)

Total: 16 + 4N + NX32 = 16 + 36N

32 bytes

Memory requirementsfor arrays ofprimitive-type values (left)and objects (right)

4.1 Performance

type

int[]

doubl e[]

Charged

int[][]

doubled []

String

Typical memory requirementsfor variable-length

data structures

bytes

4N+16

8N+16

36N+16

4N2 + 20N+16

8N2 + 20N+16

2N+40

the same object (aliasing). Normally, we do not needto account for such aliasing in our code, with one significant exception: in conjunction with Java Stringobjects, as discussed next.

String values and substrings. A String of lengthN typically uses 24 bytes (for the Stri ng object) plus2JV + 16bytes (for the array that contains the characters) for a total of 2JV + 40 bytes. It is typical in stringprocessing to work with substrings, and Java's stringrepresentation enables us to do so without having tomake copies of the string's characters. When you use

the substringO method, you create a new String object (24 bytes) but do notmake copies of any characters, so a substring of an existing string takes just 24 bytes.The substring stores an aliasto the character array in the original string, and uses theoffset and count fields to identify the substring. In other words, a substring takes constant extra memory (andforming a substring takes constant time), even when thelengths of the string and the substring are huge. A naiverepresentation that requires copying characters to makesubstrings would take linear time. The ability to createsubstrings using a constant extra memory (and constanttime) is the keyto efficiency in manybasicstring-processing algorithms, as we will see in the next section (Program4.2.8). On the other hand, this representation requiresthat all of the charactersin a string be contiguousin somearray,which implies that the string concatenation methodconcatO (which is called when the built-in + operatoris used) has to copy characters from the two strings intoa new array and thus takes time and extra space proportional to the total numberof characters in the two strings. Java's StringBuilder class is an alternative thatimplements string concatenation more efficiently than does Stri ng.

Two-dimensional arrays. As we saw in Section 1.4, a two-dimensional arrayinJava is an array of arrays. For example, the two-dimensional array in Markov

493

String genomeString codon

"CGCCTGCCGTCTGTAC";genome.substring(6, 3);

genome

codon

A Stri ng and a substring


(Program 1.6.3)uses 16bytes (overheadfor the array of arrays) plus 4JVbytes (references to the row arrays) plus JV times 16 bytes (overhead from the row arrays)plus JV times JV times 8 bytes (for the JV doubl e values in each of the JV rows) for agrand total of 8JV2 + 20JV + 16 - 8JV2 bytes. If the array entries are objects, then asimilar accounting gives 4JV2 + 20JV + 16 - 4JV2 bytes for the array of arrays filledwith references to objects, to which we need to add the memory for the objectsthemselves.

These basic mechanisms are effective for estimating the memory usage of a greatmany programs, but there are numerouscomplicating factors that can make the tasksignificantly more difficult. We have alreadynoted the potential effect of aliasing. Moreover, memory consumption is a complicateddynamic process when function calls are involved because the system memory allocation mechanism plays a more important role,with more system dependencies. For example,when your program callsa method, the systemallocates the memory needed for the method(for its local variables) from a special area ofmemory calledthe stack, and when the methodreturns to the caller, the memory is returnedto the stack. For this reason, creating arraysor other large objects in recursive programsis dangerous, since each recursive call impliessignificantmemory usage.When you create anobject with new, the system allocates the memory needed for the object from another specialarea of memory known as the heap, and youmust remember that every object lives until noreferencesto it remain, at which point a systemprocess known as garbage collection reclaimsits memory for the heap. Such dynamics canmake the task of precisely estimating memoryusage of a program challenging.

doubl e[][] t = new doubl e [N] [N];

16 bytes

8N bytes

Total: 16 + 4N + NX16 + NX8N = 8N2 + 20N + 16

Memory requirementsfor a 2D array

4.1 Performance 495

Perspective Good performance is important. An impossibly slow program isalmost as useless as an incorrect one, so it is certainly worthwhile to payattentionto the cost at the outset, to have some idea of what sorts of problems you mightfeasibly address. In particular, it is always wise to have some idea of which codeconstitutes the inner loop of your programs.

Perhaps the most common mistakemade in programming is to pay too muchattention to performance characteristics. Your first priority is to make your codeclear and correct. Modifying a program for the sole purpose of speeding it up isbest left for experts. Indeed, doing so is often counterproductive, as it tends to create code that is complicated and difficult to understand. C.A. R. Hoare (the inventor of Quicksort and a leading proponent of writing clear and correct code) oncesummarized this idea by sayingthat ''premature optimization is the root ofall evil,"to which Knuth added the qualifier"(or at least most of it) in programming." Beyond that, improving the running time is not worthwhile if the available cost benefits are insignificant. For example, improving the running time of a program bya factor of 10 is inconsequential if the running time is only an instant. Evenwhena program takes a few minutes to run, the total time required to implement anddebug an improved algorithm might be substantially more than the time requiredsimply to run a slightlyslowerone—you may as welllet the computer do the work.Worse, you might spend a considerable amount of time and effort implementingideas that should improve a program but actuallydo not do so.

Perhaps the second most common mistakemade in developingan algorithmis to ignore performance characteristics. Faster algorithms are often more complicated than brute-force solutions, so you might be tempted to accept a sloweralgorithm to avoid having to deal with more complicatedcode. However, you cansometimes reap huge savingswith just a fewlines of good code. Users of a surprising number of computer systemslose substantial time waiting for simple quadraticalgorithms to finish solving a problem, even though linear or linearithmic algorithms are available that are only slightly more complicated and could thereforesolvethe problem in a fraction of the time.When weare dealingwith huge problemsizes,we often have no choice but to seekbetter algorithms.

Improving a program to make it clearer, more efficient, and elegant shouldbe your goal every time that you work on it. If you pay attention to the cost all theway through the development of a program, you will reap the benefits every timeyou use it.


Q. How do I find out how long it takes to add or multiply two doubl e values on mycomputer?

A. Run some experiments! The program TimePrimitives on the booksite usesStopwatch to test the execution time of various arithmetic operations on primitivetypes. This technique measures the actual elapsed time as would be observed on awall clock.If your systemis not running many other applications, this can produceaccurate results. Youcan find much more information about refining such experiments on the booksite.

Q. How much time do functions such as Math.sqrtO, Math.logO, and Math.

sin() take?

A. Run some experiments! Stopwatch makes it easy to write programs such asTi meP ri mi ti ves to answer questions of this sort for yourself, and you will be ableto use your computer much more effectively if you get in the habit of doing so.

Q. How much time do string operations take?

A. Run some experiments! (Haveyou gotten the messageyet?)The standard implementation is written to allow the methods 1ength(), charAt (), and substri ng()to run in constant time. Methods such as tol_owerCase() and replaceO are linear in the string size. The methods compareToO, and startsWithO take timeproportional to the number of characters needed to resolvethe answer (constant inthe best case and linear in the worst case), but i ndexOf () can be slow. String concatenation takes time proportional to the total number of characters in the result.

Q. Why does allocating an array of sizeJV take time proportional to N?

A. In Java, all array elements are automatically initialized to default values (0,false, or null). In principle, this could be a constant time operation if the system would defer initialization of each element until just before the program accesses that element for the first time, but most Java implementations go throughthe whole array to initialize each value.

Q. How do I find out how much memory is available for my Javaprograms?

4.1 Performance

A. Since Java will tell you when it runs out of memory, it is not difficult to runsome experiments. For example, if you use PrimeSieve (Program 1.4.3) by typing


and get the result

50847534

but then type


and get the result

Exception in thread "main"java.lang.OutOfMemoryError: Java heap space

then you can figure that you have enough room for an array of 100million bool -ean values but not for an array of 1 billion boolean values. You can increase theamount of memory allotted to Java with command-lineflags. The following command executes PrimeSieve with the command-line argument 1000000000, requesting a maximum of 1100 megabytesof memory (if available).

Java -XmxllOOmb PrimeSieve 1000000000

Q. What doesit meanwhensomeone says that the running time of an algorithmisO(NlogJV)?

A. That is an example of a notation known as big-Oh notation. We write /(JV) is0(g(N)) if there exists a constant c such that/(JV) < cg(N) for all JV. We also saythat the running time of an algorithmis0(g(N)) if the running time is 0(g(N)) forall possible inputs. This notation is widely used by theoreticalcomputer scientiststo prove theorems about algorithms, so you are sure to seeit if you take a course inalgorithms and data structures. It provides a worst-caseperformance guarantee.

497


Q. So can I use the fact that the running time of an algorithm is 0(JVlog JV) or0(N2) to predict performance?

A. No, because the actual running time might be much less.Perhaps there is someinput for which the running time is proportional to the given function, but perhapsthe that input is not found among those expected in practice. Mathematically, big-Oh notation is lessprecise than the tilde notation we use: iff(JV) ~ g(JV), then/(JV)is 0(g(JV)),but not necessarily vice versa. Consequently, big-Oh notation cannotbe used to predict performance. For example, knowledge that the running time ofone algorithm is 0(N log N) and the running time of another algorithm is 0(N2)does not tell you which will be faster when you run implementations of them.Generally, hypothesesthat usebig-Oh notation are not useful in the context of thescientificmethod because they are not falsifiable.

4.1 Performance

Exercises

4.1.1 Implement the method pri ntAl1() for Th reeSum, which prints all of thetriples that sum to zero.

4.1.2 ModifyTh reeSum to take a command-line argument x and find a triple ofnumbers on standard input whose sum is closest to x.

4.1.3 Writea program Fou rSum that takes an integerJV from standard input, thenreads JV long values from standard input, and counts the number of 4-tuples thatsum to zero. Usea quadruple loop.What is the order of growthof the running timeof your program? Estimate the largest JV that your programcan handle in an hour.Then, run your program to validateyour hypothesis.

4.1.4 Prove by induction that the number of distinct pairs of integersbetween0 and JV-1 is N(N—1)/2, and then proveby induction that the number of distincttriples of integers between 0 and JV-1 is JV(JV-1) (JV-2)/6.

Answerforpairs: Theformulais correctfor JV = 1,since thereare0 pairs.ForJV> 1,count all the pairs that do not includeJV-1, which is N(N-1)/2 by the inductivehypothesis, and all the pairs that do includeJV-1, whichis JV— 1,to get the total

(JV-l)(JV-2)/2 +(JV-1) = JV(N-l)/2.

Answerfortriples: The formula is correct for JV = 2. For JV> 2, count all the triplesthat do not includeJV-1, whichis (N- l)(JV-2)(JV-3)/6 bythe inductivehypothesis, and all the triples that do include JV-1, which is (JV-1)(JV— 2)/2, to get thetotal

(JV-l)(JV-2)(JV-3)/6 + (JV-l)(JV-2)/2 = JV(N-l)(JV-2)/6.

4.1.5 Show by approximating with integrals that the number of distinct triplesof integers between 0 and JV is about JV3/6.

Answer: 20N2^ 1- ^r';fSXf'o dkdjdi = iXjdjdi= /0V/2)<£ = N3/6.

4.1.6 What is the value of x after running the following code fragment?

int x = 0;for (int i =0; i < N;

for (int j = i + 1;for (int k = j +

x++;


i++)j < N; j++)1; k < N; k++)

Answer:JV(JV-l)(JV-2)/6.

4.1.7 Use tilde notation to simplifyeach of the following formulas, and givetheorder of growth of each:

a. N(N- l)(JV-2)(JV-3)/24b. (JV-2)(lgJV-2)(lgJV+2)c. JV(JV + 1)-JV2d. JV(JV + l)/2 + JVlgJVe. ln((JV- l)(JV-2)(JV-3))2

4.1.8 Determine the order of growth of the running time of the input loop ofThreeSum:

int N = Integer.parselnt(args[0]);int[] a = new int[N] ;for (int i =0; i < N; i++)

a[i] = Stdln.readlntO;

Answer: Linear.The bottlenecks are the array initialization and the input loop. Depending on your systemand the implementation, the readlntO statement mightlead to inconsistent timings for small values of JV. The cost of an input loop likethis might dominate in a linearithmic or even a quadratic program with JV that isnot too large.

4.1.9 Determine whether the following code fragment is linear, quadratic, or cubic (as a function of JV).


if (i == j) c[i][j] = 1.0;else c[i][j] = 0.0;

4.1 Performance

4.1.10 Supposethe running time of an algorithmon inputs of sizeone thousand,two thousand, three thousand, and four thousand is 5 seconds, 20 seconds, 45 seconds,and 80seconds, respectively. Estimate howlongit will take to solve a problemof size 5,000. Is the algorithm linear, linearithmic, quadratic, cubic, or exponential?

4.1.11 Which wouldyou prefer: a quadratic, linearithmic, or linear algorithm?

Answer: Whileit is temptingto make a quickdecision basedon the order of growth,it isveryeasy to be misled bydoingso. You needto have someideaof the problemsize and of the relative value of the leading coefficients of the running time. Forexample, suppose that the runningtimes areJV2 seconds, 100JVlog2 JV seconds, and10000JV seconds. The quadratic algorithm will be fastest for JV up to about 1000,and the linear algorithm will never be faster than the linearithmic one (JV wouldhave to be greater than 2100, far too large to botherconsidering).

4.1.12 Apply the scientific method to develop and validate a hypothesis aboutorder of growthof the running time of the following codefragment, as a functionof the input argument n.

public static int f(int n){

if (n == 0) return 1;return f(n-l) + f(n-l);

}

4.1.13 Apply the scientific method to develop and validate a hypothesis aboutorder of growth of the running time of the collectO method in Coupon (Program 2.1.3), as a function of the input argument N. Note: Doubling is not effectivefor distinguishing between the linear and linearithmic hypotheses—you might trysquaring the size of the input.

4.1.14 Apply the scientific method to develop and validate a hypothesis aboutorder of growth of the running time of Markov (Program 1.6.3), as a function ofthe input parameters T and N.

501


4.1.15 Apply the scientific method to develop and validate a hypothesis aboutorderofgrowth of therunning time ofeach of thefollowing two code fragments asa function of N.

String s = "";for (int i = 0; i < N; i++)

if (StdRandom.bernoulli(0.5)) s += "0";else s += "1";

StringBuilder sb = new StringBuilderO;for (int i = 0; i < N; i++)

if (StdRandom.bernoulli(0.5)) sb.append("0");else sb.appendCl");

String s = sb.toStringO;

Answer: The first is quadratic; the second is linear.

4.1.16 Each of the four Java functions below returns a string of length Nwhosecharacters are all x. Determine the order of growth of the running time of eachfunction. Recall that concatenating two strings in Java takes time proportional tothe sum of their lengths.

public static String methodl(int N){

if (N == 0) return "";String temp = methodl(N / 2);if (N % 2 == 0) return temp + temp;else return temp + temp + "x";

}

public static String method2(int N){


s = s -

return s;

4.1 Performance


if (N == 0) return "";if (N == 1) return "x";return method3(N/2) + method3(N - N/2);

}


char[] temp = new char[N];for (int i = 0; i < N; i++)

temp[i] = fxf;return new String(temp);

}

4.1.17 The following code fragment (adapted from a Java programming book)createsa random permutation of the integersfrom 0 to JV-1. Determine the orderof growth of its running time asa function of JV. Compare itsorder of growthwiththe shuffling code in Section 1.4.

int[] a = new int[N];boolean[] taken = new boolean[N];int count = 0;while (count < N)

{int r = StdRandom.uniform(N);if (!taken[r]){

a[r] = count;taken[r] = true;count++;

}}

4.1.18 What is order of growth of the running time of the following function,which reverses a string s of length N?


public static String reverse(String s){

int N = s.lengthO;String reverse = "";for (int i = 0; i < N; i++)

reverse = s.charAt(i) + reverse;return reverse;

}

4.1.19 What is the order of growthof the running time of the following function,which reverses a string s of length N?


int N = s.lengthO;if (N <= 1) return s;String left = s.substring(0, N/2);String right = s.substring(N/2, N);return reverse(right) + reverse(left);

}

4.1.20 Give a linear algorithm for reversing a string.

Answer:


int N = s.lengthO;char[] a = new char[N];for (int i = 0; i < N; i++)

a[i] = s.charAt(N-i-l);return new String(a);

}

4.1.21 Write a program MooresLaw that takes a command-line argument JV andoutputs the increase in processor speed over a decade if microprocessors doubleeveryJV months. How much will processorspeed increase over the next decade ifspeeds double every JV= 15 months? 24 months?

4.1 Performance

4.1.22 Using the modelin the text, give the memory requirements for each objectof the followingdata types from Chapter 3:

a. Stopwatch

b. Turtle

c. Vector

d. Body

e. Universe

4.1.23 Estimate, asa function of thegridsize JV, the amountof space usedbyVi -sualize (Program 2.4.3) with the vertical percolationdetection (Program 2.4.2).Extra credit: Answer the same question for the case where the recursive percolationdetection method in Program 2.4.5 is used.

4.1.24 Estimate the size of the biggest two-dimensional arrayof i nt values thatyour computercan hold,and then try to allocate suchan array.

4.1.25 Estimate, as a function of the number of documents JVand the dimensiondy the amount of spaceused by CompareAl 1 (Program 3.3.5).

4.1.26 Write a version of Pri meSi eve (Program 1.4.3) that uses a byte arrayinstead of a bool ean array and uses allthebitsin each byte, to raise the largest valueof Nthat it can handle by a factor of 8.

4.1.27 The following tablegives running times for various programs for variousvalues of JV. Fill in the blanks with estimates that you think are reasonable on thebasisof the information given.

program 1,000

A .001 seconds

B 1 minute

C 1 second

10,000 100,000 1,000,000

.012 seconds .16 seconds ? seconds

10 minutes 1.7 hours ? hours

1.7minutes 2.8 hours ? days

Give hypotheses for the order of growthof the running time of eachprogram.

505


^reatm^^MBmi

4.1.28 ThreeSum analysis. Calculate the probabilitythat no triple amongJV random 32-bit integers sums to 0, and give an approximate estimate for JV equal to1000,2000,and 4000. Extra credit: Give an approximate formula for the expectednumber of such triples (asa function of JV), and run experiments to validate yourestimate.

4.1.29 Closest pair. Design a quadratic algorithm that finds the pair of integersthat are closest to each other. (In the next section you will be asked to find a linearithmic algorithm.)

4.1.30 Power law. Show that a log-log plot of the function cNb has slope b andx-intercept logc. Whatare the slope and x-intercept for 4 JV3 (logJV)2 ?

4.1.31 Sumfurthestfrom zero. Design an algorithm that finds the pair of integerswhosesum is furthest from zero. Can you discover a linear algorithm?

4.1.32 The "beck" exploit. A popular web server supports a function calledno2slash() whose purpose is to collapse multiple / characters. For example, thestring/dl///d2////d3/test. html becomes /dl/d2/d3/test. html.Theoriginalalgorithm was to repeatedly search for a / and copy the remainder of the string:

void no2slash(char[] name)

{for (int x = 0; x < name.length; )

if (x > 0)if C(name[x-1] == '/') && (name[x] == '/'))

for(int y = x+1; y < name.length; y++)name[y-l] = name[y];

else x++;

}

Unfortunately, the running time of this code is quadratic in the number of/ characters in the input. Bysending multiple simultaneous requests with largenumbersof / characters, a hacker can deluge a server and starve other processes for CPUtime, thereby creatinga denial-of-service attack.Develop a version of no2sl ash ()that runs in linear time and does not allow for the this type of attack.

4.1 Performance

4.1.33 Young tableaux. Suppose you have in memoryan JV-by-JV grid of integersasuchthata[i][j] < a[i+l] [j] anda[i] [j] < a[i] [j+1] foralli and j, likethe table below.

5 23 54 67 89

6 69 73 74 90

10 71 83 84 91

60 73 84 86 92

99 91 92 93 94

Devise an algorithm whose order of growth is linear in JV to determine whether agiven integer x is in a given Youngtableaux.Answer: Start at the upper-right corner.If the valueisx, return true. Otherwise,goleft if the valueis greaterthan x and godownif the value isless than x. If you reachbottom left corner, then x is not in table. The algorithm is linear because you cango left at most JV times and down at most JV times.

4.1.34 Subsetsum. Writea programAnySum that takes an integerJV from standardinput, then reads JV long values from standard input, and counts the number ofsubsets that sum to 0. Give the order of growth of the running time of your program.

4.1.35 String rotation. Givenan array of JV elements, give a linear time algorithmto rotate the string kpositions. That is, if the array contains a0, av ..., aN_}, the rotated array is ak, ak+v ..., aN_p a0,..., z.k_v Use at most a constant amount of extraspace (array indicesand array values). Hint: Reverse three subarraysas in Exercise4.1.20.

4.1.36 Finding a duplicated integer, (a) Given an array of JV integers from 1 to JVwith one value repeated twice and one missing, give an algorithm that finds themissing integer, in linear time and constant extra space. Integer overflowis not allowed, (b) Given a read-only array of JV integers, where each value from 1 to JV— 1occurs once and one occurs twice, givean algorithm that finds the duplicated value,in linear time and constant extra space, (c) Given a read-only array of JV integerswith valuesbetween 1 and JV-1, give an algorithm that finds a duplicated value,inlinear time and constant extra space.


4.1.37 Factorial. Design a fast algorithm to compute JV! for large values of JV, usingJava's Bi glnteger class. Use yourprogram to compute the longest run of consecutive 9s in 1000000!. Develop and validate a hypothesisfor the order of growthof the running time of your algorithm.

4.1.38 Maximum sum. Design a linear algorithm that finds a contiguous subsequence of at most M in a sequence of JV 1ong integers that has the highest sumamong all such subsequences. Implement your algorithm, and confirm that theorder of growth of its running time is linear.

4.1.39 Pattern matching. Given an JV-by-JV array of black (1) and white (0) pixels, design a linearalgorithm that finds the largest square subarray that consists ofentirelyblackpixels. In the example below there is a 3-by-3 subarray.

Implement your algorithm and confirm that the order of growth of its runningtime is linear in the number of pixels. Extra credit: Design an algorithmto find thelargest rectangular black subarray.

4.1.40 Maximum average. Write a program that finds a contiguous subarray ofat most M elements in an array of JV long integers that has the highest averagevalue amongall suchsubarrays, by tryingall subarrays. Use the scientific methodto confirm that the order of growth of the running time of your program is MN2.Next, write a program that solves the problem by first computing prefi x[i ] =a [0] + ... + a[i ] for each i, then computing the average in the interval froma[i] to a[j] with the expression (prefix[j] - prefix[i]) / (j - i + l).Usethe scientific method to confirm that this method reduces the order of growth by afactor of JV.

4.1 Performance

4.1.41 Sub-exponentialfunction. Find a function whose order-of-growth is slower than any polynomial function, but faster than any exponential function. Extracredit Find a program whose running time has that order of growth.

509


4.2 Sorting and Searching

The sorting problemis to rearrange a set of items in ascending order. It is a familiar and critical task in many computational applications: the songs in your music library are in alphabetical order, your email messages are in order of the timereceived, and so forth. Keeping things insome kind of order is a natural desire.

One reason that it is so useful is that it 4.2.1 Binarysearch (20 questions) 512

is much easier to search for something in *22 Bjsection 8Cf* ' ': ' ' \ 515, ,. . , J;. . 4.2.3 Binary search (sorted array) . . . .517

a sorted list than an unsorted one. This 424 Insertionsort 524need is particularly acute in computing, 4.2.5 Doubling test for insertion sort. . .526where the list of things to search can be 4.2.6 Mergesort 528huge and an efficient search can be an 4-2-7 Frequency counts 533

. . r 4. ui > I*- 4.2.8 Longest repeated substring 539important factor in a problems solution. & Y &Sorting and searching are impor- Programs in this section

tant for commercial applications (businesses keep customer files in order) andscientific applications (to organize data and computation), and have all mannerof applications in fields that may appear to have little to do with keeping things inorder, including data compression, computer graphics, computational biology, numerical computing, combinatorial optimization, cryptography, and many others.

We use these fundamental problems to illustrate the idea that efficient algorithms are one key to effective solutions for computational problem. Indeed, manydifferent sorting and searching methods havebeen proposed. Which should we useto address a given task?This question is important because different programs canhave vastly differing performance characteristics, enough to make the differencebetween success in a practical situation and not coming close to doing so, even onthe fastest available computer.

In this section, we will consider in detail two classical algorithms for sortingand searching, along with severalapplications in which their efficiencyplaysa critical role. With these examples, you will be convinced not just of the utility of thesemethods, but also of the need to pay attention to the costwhenever you address aproblem that requires a significant amount of computation.


Binary search The game of "twenty questions"(seeProgram 1.5.2)provides animportant and useful lesson in the idea of designingand using efficient algorithmsfor computational problems. The setup is simple:your task is to guess the value ofa hidden number that is one of the JV integersbetween 0 and JV— 1.Each time thatyou make a guess,you are told whether your guess is equal to the hidden number,too high, or too low.Aswe discussed in Section 1.5,an effective strategy is to guess

the number in the middle of the in

terval, then use the answer to halvethe interval size. For reasons that will

become clear later,we begin by slightly modifying the game to make thequestions of the form "is the numberless than m ?" with true or false answers, and assume for the momentthat N is a power of two. Now, the basis of an effective method that alwaysgets to the hidden number in a minimal number of questions is to maintain an interval that contains the hid

den number and shrinks by half ateach step. More precisely, we use ahalf-open interval, which contains theleft endpoint but not the right one.We use the notation [/, h) to denote

all of the integers greater than or equal to / and less than (but not equal to) h.Westart with / = 0 and h —N and use the followingrecursivestrategy:

• Base case: If h —I is 1, then the number is /.

• Recursive step:Otherwise, ask whether the number is less than the numberm = 1+ (h—l )/2. If so, look for the number in [/, ra); if not, look for thenumber in [ra,/z).

This strategy is an example of the general problem-solving method known as binarysearch, which has many applications. TwentyQuesti ons (Program 4.2.1) is animplementation.

interval

-1=64

64

76 80

7678

96

—T128

128

128

Q

<64? false

64 < 96 ? true

32 < 80 ? true

16 <72? false

8 <76? false

< 78 ? true

2 <77? false

•-11

Findinga hidden number with binary search

511


Program4,2.1 Binary search (20 questions)

public class TwentyQuestions{

public static int search(int lo, int hi){ // Find number in [lo, hi)

if ((hi - lo) == 1) return lo;int mid = lo + (hi - lo) / 2;StdOut.print("Less than " + mid + "? ");if (Stdln.readBooleanO)

return search(lo, mid);else return search(mid, hi);

}

$$i

public static void main(String[] args){ // Play twenty questions.

int n = Integer.parselnt(args[0]);int N = (int) Math.pow(2, n);StdOut.print("Think of a number ");StdOut.println("between 0 and " + (N-l));int v = search(0, N);StdOut.println("Your number is " + v);

}

lo

hi - 1

mid

n

smallestpossible value

largest possible value

midpoint

number of questions

number ofpossible values

This code uses binary search toplay thesamegame as Program 1.5.2, but with the roles reversed: you provide the number and theprogram guesses its value. It takes a command-lineargument ny asks you to think of a number between 0 and N—l, where N = 2", and alwaysguesses theanswer with n questions.

% Java TwentyQuestions 7Think of a number between 0 and 127

Less than 64? false

Less than 96? true

Less than 80? true

Less than 72? false

Less than 76? false

Less than 78? true

Less than 77? false

Your number is 77

^"W^^-^^S^^^^^^^pp^*

4.2 Sorting and Searching 513

Correctness proof First,wehave to convince ourselves that the method is correct:that it always leads us to the hidden number.Wedo so by establishingthe followingfacts:

• The interval always contains the hidden number.• The interval sizesare the powers of two, decreasingfrom N.

The first of these facts is enforced by the code; the second follows by noting that if(h —I) is a power of two, then (h —I )/2 is the next smaller power of two and alsothe sizeof both halved intervals. These factsare the basis of an induction proof thatthe method operates as intended. Eventually, the interval sizebecomes 1, so we areguaranteed to find the number.

Analysis of running time. Since N is a power of 2, we write N = 2", where n =IgiV. Now,let T(N) be the number of questions. The recursivestrategy immediatelyimplies that T(N) must satisfythe followingrecurrence relation:

T(N) = T(N/2) + l

with T(l) = 1. Substituting 2" for N, we can telescope the recurrence (apply it toitself) to immediately get a closed-form expression:

T(2«) = TC2""1) + 1 = T(2«"2) -1- 2 = ...= T(l) + n-l = n.

Substituting back JV for 2n (and IgiV for n) gives the result

T(N) = IgiV

We normally use this equation to justify a hypothesis that the running time of aprogram that uses binary search is logarithmic. Note: Binary search and Twenty-Questi ons. search () work even when N is not a power of two—we just assumedthat iV is a power of two to simplifyour proof (seeExercise 4.2.14).

Linear-logarithmic chasm. The alternative to using binary search is to guess 0,then 1, then 2, then 3, and so forth, until hitting the hidden number. We refer tosuch an algorithm as a brute-force algorithm: it seemsto get the job done, but without much regard to the cost (which might prevent it from actually getting the jobdone for large problems). In this case, the running time of the brute-force algorithm is sensitive to the input value, but could be as much as N and has expectedvalue iV/2 if the input value is chosen at random. Meanwhile,binary search is guaranteed to use no more than IgiVsteps.Asyou will learn to appreciate, the difference


between N and IgiV makes a huge difference in practical applications. Understanding the enormousness of this difference is a critical step to understanding the importance of algorithm design andanalysis. In the present context, suppose that it takes1 second to process a guess. With binary search, you can guess the value of anynumber less than 1 million in 20 seconds;with the brute-force algorithm, it mighttake 1 million seconds, which is more than 1 week. We will see many exampleswhere such a cost difference is the determining factor in whether or not a practicalproblem can be feasiblysolved.

Binary representation. If youlook back to Program 1.3.7,

you will immediately recognizethat binary search is nearly thesame computation as converting a number to binary! Eachguess determines one bit of theanswer. In our example, theinformation that the number

is between 0 and 127 says thatthe number of bits in its binaryrepresentation is 7, the answerto the first question (is thenumber less than 64?) tells usthe value of the leading bit, theanswer to the second questiontells us the value of the next bit,and so forth. For example, ifthe number is 77, the sequenceof answers no yes yes no no yes no immediately yields 1001101, the binaryrepresentation of 77.Thinking in terms of the binary representation is another wayto understand the linear-logarithmic chasm: when we have a program whose running time is linear in a parameter iV, its running time is proportional to the value ofiV, whereas a logarithmic running time is just proportional to the number of digitsin N. In a context that is perhaps slightlymore familiar to you, think about the following question, which illustrates the same point: would you rather earn $6 or asix-figure salary?

the known value

is between

<£(/) and <£>{m)

the unknown value

is between I and m

Binary search (bisection) to invert an increasingfunction


^^•^^^^^^^^^BSBBB^^^^^^^M

Program 4.2.2 Bisection search (function inversion)

public static void Phi Inverse(double y){ return Philnverse(y, .00000001, -8, 8) }

private static double PhiInverse(double y, double delta,double lo, double hi)

{ // Compute x with Phi(x) = y.double mid = lo + (hi - lo)/2;if (hi - lo < delta) return mid;if (Phi(mid) > y)

return Philnverse(y, delta, lo, mid);else return Philnverse(y, delta, mid, hi);

515

^&$M^

;'•• i

••'•3.

;.-•• \t

1

y

delta

lo

mid

hi

argument

precision

smallestpossible value

midpoint

largest possible value}

This implementation of PhiInverse () for ourGaussian library (Program 2.1.2) uses binarysearch to compute a valuexfor which $>(x) is equal toa givenvaluey, within a givenprecisiondelta. It is a recursive function thathalves the interval containing thegiven value, evaluatesthefunction at themidpoint of the interval and takes advantage of thefact thatO is increasingtodecide whether the desired pointis in the left halforthe right half continuing until theinterval size is less than thegivenprecision.

Inverting a function. As an example of the utility of binary search in scientificcomputing, we revisit a problem that we first encountered in Section 2.1: invertingan increasingfunction. To fix ideas,we refer to the Gaussiancumulative distribution function <E> when describingthe method, but it worksfor any increasingfunction. Givena valuey, our task is to find a valuex such that 4>(x) =y. In this situation, we use real numbers as the endpoints of our interval,not integers,but we usethe sameessential method as for guessing a hidden integer: wehalve the sizeof theintervalat eachstep,keeping x in the interval, until the intervalis sufficiently smallthat weknow the value of x to within a desiredprecision8.Westart with an interval(/, h) known to contain x and use the following recursive strategy:

• Compute m = / + (h—l)/2.• Base case: If h —/ is less than 8, then return m as an estimate of x.• Recursive step: Otherwise, testwhether <£(m) >y. If so, lookforx in (/, m);

if not, look for x in (m, h).


The key to this method is the idea that the function is increasing—for any values aand by knowing that <I>(a)<0(b) tells us that a<b, and vice versa. The recursivestep just applies this knowledge: knowing thaty = <l>(x) < <I>(ra) tells us that x<m,so that x must be in the interval (/, m), and knowing that y = ®(x) > O(m) tells usthat x > m,so that x must be in the interval (m,h). You can think of the problem asdetermining which of the N = (h-1 )/8 tiny intervals of size8 within (/,h) containsx, with running time logarithmic in N.Aswith number conversionfor integers,wedetermine one bit of x for each iteration. In this context, binary search is oftencalled bisection search because we bisect the interval at each stage.

thekey(known value)

is between

a [mid] and a [hi -1]

the index

(unknown value)is between mi d and hi

Binary search in a sorted array. One of the mostimportant uses of binary search is to find a piece ofinformation using a key to guide the search. This usageisubiquitous in modern computing, to the extentthat printed artifacts that depend on the same concepts are wellon their wayto becoming obsolete. Forexample,during the last fewcenturies, people woulduse a publication known as a dictionary to look upthe definition of a word, and during much of the lastcentury people would use a publication known as aphone book to look up a person's phone number. Inboth cases, the basic mechanism is the same: entries

appear in order, sorted by a key that identifies it (theword in the case of the dictionary, and the personsname in the caseof the phone book, sorted in alphabetical order in both cases). You probably use yourcomputer to reference such information, but think

about how you would look up a word in a dictionary.Abrute-force solution wouldbe to start at the beginning, examine each entry one at a time, and continue untilyou find the word. No one uses that method: instead, you open the book to someinterior page and look for the word on that page. If it is there, you are done; otherwise, you eliminate either the part of the book before the current page or the partof the book after the current page from consideration, and then repeat. We nowrecognize this method as binary search. Whether or not you look exactly in themiddle is immaterial; as long as you eliminate at least a fraction of the entries eachtime that you look, your searchwillbe logarithmic (see Exercise 4.2.15).

Binary search in a sorted array (onestep)


wmmmmms^s^^^^^^^^^m^^^mm^M^m^mw

S3

Program 4.2.3 Binary search (sorted array)

public class BinarySearch{

public static int search(String key, String[] a){ return search(key, a, 0, a.length); }

public static int search(String key,String[] a, int lo, int hi){ // Search for key in a[lo, hi).

if (hi <= lo) return -1;int mid = lo + (hi - lo) / 2;int cmp = a[mid].compareTo(key);if (cmp > 0) return search(key,else if (cmp < 0) return search(key,else return mid;

}

a, lo, mid);a, mid+1, hi);

i

public static void main (Stri ng[] args){ // Print keys in Stdln that are not found

// in the whitelist file args[0].In in = new In(args[0]);String[] a = in. readAHO .split("WS+") ;while (!Stdln.isEmptyO){

String key = Stdln. readStringO ;if (search(key, a) < 0) StdOut.println(key);

}

key

a[]

lo

mid

hi

stringsought

sortedlist of strings

smallest possible index

midpoint

largest possible index

The search () method in this class uses binary search tofind theindex ofa string key in a sortedarray (or returns -1 if the string is not in the array). The test client is an exception filter thatreads a (sorted) whitelist from the file given on the command lineandprints thewords fromstandard input thatare not in thewhitelist.

more test.txt

bob@office

carl©beach

marvin@spambob@office

bob@office

mallory@spamdave@boat

eve@airportali ce@home

!^?£p£?f»^^îi^^f^fpp^

îM^MiitMî,

% more whitelist.txt

ali ce@home

bob@office

carl©beach

dave@boat

% Java BinarySearch whitelist.txt < test.txtmarvin@spammallory@spam

eve@airport

î^^^^^^^^^^^^^sm^^^^^^^s^mm^^!^^^^^mmm

SS


Exception filter. We will consider in Section 4.3 the details of implementing thekind of computerprogramthat you usein place of a dictionary or a phone book.Program 4.2.3 uses binary search to solve the simpler existence problem: is a givenkeyin a sorted database of keys, or not? For example, when checking the spellingof a word,you need onlyknowwhetheryour word is in the dictionary and are notinterested in the definition. In a computer search, we keep the information in anarray,sorted in order of the key (for some applications, the information comes insorted order; for others,wehaveto sort it first, using one of the methods discussedlater in this section).The binary searchin Program 4.2.3 differs from our other applications in two details.First,the file sizeN need not be a power of two.Second,ithas to allow the possibility that the item sought is not in the array. Coding binarysearch to account for these details requires some care, as discussed in this section'sQ&A and exercises. The test client in Program 4.2.3 is known as an exception filter.it reads in a sorted list of strings from a file (which we refer to as the whitelist) andan arbitrary sequence of strings from standard input, and prints those in the sequencethat are not in the whitelist. Exception filters havemany direct applications.For example, if the whitelist is the words from a dictionary and standard inputis a text document, the exception filter will print the misspelled words. Anotherexamplearises in web applications: your email application might use an exceptionfilter to reject any mail messages that are not on a whitelist that contains the mailaddresses of your friends, or your operating systemmight have an exceptionfilterthat disallows networkconnections to your computerfrom anydevice havingan IPaddress that is not on a preapproved whitelist.

Weighing an object. Binary search hasbeenknownsince antiquity, perhaps partlybecause of the following application. Suppose that you needto determinethe weightof a given object using only a balancing scale. With binary search,you can do sowith weights that are powers of two (you need only one weight of each type). Putthe objecton the left sideof the balance and try the weights in decreasing order onthe right side. If a weight causesthe balance to tilt to the left, remove it; otherwise,leave it. This process is precisely analogous to determining the binary representation of a number by subtracting decreasingpowers of two, as in Program 1.3.7.


twenty questions(converting to binary)

1??????

greater than64

less than 64+32

/10?????

. fess(/i<w64+16

100????

1001???

greater than64+8

10011??

greaterthan64+8+4

less than 64+8+4 + 2

/100110?

equalto64+8+4 + 2+1

I1001101

weighing an object

i

it84

in842

_ ii .64 84 1

<96

inverting afunction

increase 4>(/) -

•• decrease <t>(r)

sr

* decrease $>{r)

V

increase 0(/K

W

increase $(/)•>

K

>decrease <£(r)

7

y = &(x)

7

Three applications of binarysearch

519


Fast algorithms are an essential element of the modern world, and binary searchis a prototypical examplethat illustrates the impact of fast algorithms.With a fewquickcalculations, you can convince yourselfthat problemslikefindingallthe misspelled wordsin a document or protecting your computer from intruders usinganexceptionfilterrequire a fastalgorithmlikebinary search.Take the time todoso. Youcan find the exceptions in a million-entry document to a million-entrywhitelistin an instant, whereas that task might take days or weeks using the brute forcealgorithm. Nowadays, web companies routinely provide services that are based onusing binary search billions of times in tables with billions ofentries—without a fastalgorithm likebinary search,we could not contemplate such services.

Whether it be extensive experimental data or detailed representations ofsome aspect of the physicalworld, modern scientists are awash in vast amounts ofdata.Binary search and fast algorithms like it areessential componentsof scientificprogress. Using a brute-force algorithm is precisely analogous to searching for awordin a dictionarybystartingat the firstpageand turning pages onebyone.Witha fastalgorithm,you can literally search among billionsof pieces of information inan instant.Taking the time to identify and usea fast algorithm for search certainlycanmake the difference between being able to solve a problemeasily and spendingsubstantial resources trying to do so (and failing).


Insertion sort Binary search requires that the databe sorted, and sorting hasmany other direct applications, so we now turn to sorting algorithms.We first consider a brute-force method, then a sophisticated method that we can use for hugedata sets.

The brute-force algorithm is known as insertion sortand is based on a simplemethod that people often use to arrange hands of playingcards. Consider the cardsone at a time and insert each into its proper placeamong those alreadyconsidered(keeping them sorted). The following code mimics this process in a Java methodthat sorts strings in an array:

public static void sort(String[] a){

int N = a.length;for (int i = 1; i < N; i++)

for (int j = i; j > 0; j—)if (a[j-l].compareTo(a[j]) > 0)

exch(a, j-1, j);else break;

}

The outer for loop sorts the first i entries in the array; the inner for loop completesthe sort by putting a[i ] into its properposition in the array, asin the following example when i is 6:

1 30 1 2 3 4 5 6 7

6 6 and had him his was you the but

6 5 and had him his was the you hut

6 4 and had him his the was you hut.

and had him his the was you but

Inserting a [6] intoposition byexchanging with larger entries to its left

Entry a[i] is put in its place among the sorted entries to its left by exchangingit (using the exch() method that we first encountered in Section 2.1) with eachlargerelement to its left, moving from right to left, until it reaches its proper position. The black entries in the three bottom rows in this trace are the ones that are

compared (and exchanged,on allbut the final iteration).The insertion process just described is executed, first with i equalto 1,then 2,

then 3, and so forth, as illustrated in the following trace.


1 J0 1 2 3 4 5 6 7

was had him and you his the but

1 0 had was him and you his the hut

2 1 had him was and you his the but

3 0 and had him was you his the but

4 4 and had him was you his the. but

5 3 and had him his was you the hut

6 4 and had him his the was you but.

7 1 and but had him his the was you

and but had him his the was you

Inserting all] through a [N-l] into position (insertion sort)

This trace displaysthe contents of the array each time the outer for loop completes,along with the value of j at that time. The highlighted element is the one that wasin a[i ] at the beginning of the loop, and the other elements printed in black arethe other ones that were involved in exchanges and moved to the right one position within the loop. Sincethe elements a[0] through a[i -1] are in sorted orderwhen the loop completes for each value of i, they are, in particular, in sorted orderthe final time the loop completes, when the value of i is a. 1ength. This discussionagain illustrates the first thing that you need to do when studying or developing anew algorithm: convinceyourself that it is correct. Doing so provides the basic understanding that you need in order to study its performance and use it effectively.

Analysis of running time. The inner loop of the insertion sort code is within adouble for loop, which suggests that the running time is quadratic, but we cannotimmediately draw this conclusion, because of the break. For example, in the bestcase,when the input array is alreadyin sorted order, the inner for loop amounts tonothing more than a comparison (to learn that a [ j -1] is less than a [j ] for each jfrom 1 to N-l) and the break, so the total running time is linear. On the otherhand, in the reverse-sorted case,the inner loop fullycompletes without a break, sothe frequencyof executionof the instructions in the inner loop is 1 + 2 + ... +N— 1 ~ N2 and the running time is quadratic. To understand the performance ofinsertion sort for randomly ordered input, take a careful look at the trace: it is anN-by-N array with one black element corresponding to each exchange. That is, thenumber of black elements is the frequencyof execution of instructions in the inner


loop.Weexpectthat eachnew element to be inserted is equallylikelyto fallinto anyposition, so that element will move halfway to the left on average. Thus, on the average,we expect only about one-half the elements below the diagonal (about N2/4in total) to be black,. This leads immediately to the hypothesis that the expectedrunning time of insertion sort for a randomly ordered input array is quadratic.

Sorting other types of data. We want to be able to sort all typesof data, not juststrings. In a scientific application, we may wish to sort experimental results by numeric values; in a commercial application, we may wish to use monetary amounts,times, or dates; in systems software, we might wish to use IP addresses or accountnumbers. The idea of sorting in each of these situations is intuitive, but implementing a sort method that works in all of them isa prime example of the need for a functional ~N72 entries ahove the diasoml are shadedabstraction mechanism like the one provided unshaded \by Java. For sorting objects in an array, we e%r!eLZ6^^ was had him and y°u his t:he but7 t . , , , j had was him and vou his the but

need only assume that we can compare two el- that moved had Mm was and you his the but

ements to see whether the first isbigger than, ™* US K» w^ 12 ^t T* tloo ' and had him was you his the butSmaller than, Or equal tOthe Second. Java pro- N2 entries^r and had him his was you the but

. , , _. , , r r • i in total and had him his the was you butvides the Comparable interface for precisely and but had him his the was youthis purpose. Simply put, a class that imple- Sments the Comparabl e interface promises to _NV4 (half) ofthe entries below theimplement a method COmpareTo() for Objects diagonal on the average, are blackof its type so that a.compareTo(b) returns anegative integer if a is less than b, a positive Analysis of insertion sortinteger if a is greater than b, and 0 if a is equalto b. The precise meanings of less than, greater than, and equal toare up to the datatype, though implementations that do not respect the natural laws of mathematicssurrounding these concepts will yield unpredictable results. With this convention,we can implement our sort method so that it sorts arrays of Comparable objects,and use compareToO to compare them, as illustrated in Insertion (Program4.2.4).As discussed in Section 3.3, Java's Stri ng type implements the Comparableinterface (we have been using its compareToO method), as does the Date type andwrappers for primitive numeric types such as Integer and Double. Thus, we canuse Inserti on. sort () to sort arrays of all of these types of data. It is also easy toimplement the interface so that we can sort user-defined types of data, as we sawin Section 3.3.


*&4

M

Program 4.2.4 Insertion sort

public class Insertion{

public static void sort(Comparable[] a){ // Sort a[] into increasing order,

int N = a.length;for (int i =1; i < N; i++)

// Insert a[i] into position by exchanging// it with the larger elements to its left,for (int j = i; j > 0; j--)

if (a[j-l].compareTo(a[j]) > 0)exch(a, j-1, j);

else break;

}

public static void exch(Comparable[] a, int i, int j){ Comparable t = a[j]; a[j] = a[j-l]; a [j-1] = t; }

public static void main(String[] args){ // Read strings from standard input, sort them, and print.

String[] a = Stdln. readAllO .split(,,\\s+M) ;sort(a);for (int i = 0; i < a.length; i++)

StdOut.print(a[i] + " ");StdOut.println();

}}

The sort O function is an implementation of insertion sort. It sorts arrays ofanytype ofdatathatimplements the Comparable interface (has a compareToO method). This method is appropriateforsmallfiles orfor largefiles that are nearly in order, butis too slow tousefor largefiles thatareoutof order.

w^^^^^w^^ss^^^^^^^^^^^^^^^^^^^^^^^^^^w^w

% more tiny.txtwas had him and you his the but

% Java Insertion < tiny.txtand but had him his the was you

% Java Insertion < TomSawyer.txttick tick tick tick tick tick tick tick tick tick tick tick tick tick tick tick tick tick tick tick

tick tick tick tick tick tick tick tick tick tick tick tick tick tick tick tick tick tick tick tick




^^^^^^Si^^^^S^^^^^^P^S^S^^BSS^^^^^^^^^lRSIS^^IBHP^PS&&mt&3^&w?-'-


Empirical analysis. Inserti onTest (Program4.2.5) testsour hypothesisthat insertion sort is quadratic for randomly ordered files by running Inserti on. sort ()on N random Doubl e values,computing the ratios of running times as N doubles.This ratio converges to 4, which validates the hypothesis that the running time isquadratic, as discussed in the last section. You are encouraged to run Insertion-Test on your own computer. As usual, you might notice the effect of caching orsome other system characteristic for some values of JV, but the quadratic runningtime should be quite evident, and you willbe quicklyconvincedthat insertion sortis too slow to be useful for large inputs.

Sensitivity to input. Note that Inserti onTest takesa command-line argumentTand runs Texperiments for each array size, not just one.Aswehavejust observed,one reason for doing so is that the running time of insertion sort is sensitive to itsinput values. This behavior is quite different from (for example) ThreeSum, andmeans that we have to carefully interpret the results of our analysis. It is not correctto flatly predict that the running time of insertion sort will be quadratic, becauseyour application might involve input for which the running time is linear.When analgorithm's performance is sensitive to input values, you might not be able to makeaccurate predictions without taking the input values into account.

There are many natural applications for which insertion sort is quadratic, so weneed to consider faster sorting algorithms.Asweknow from Section 4.1, a back-of-the-envelope calculation can tell us that having a faster computer is not much help.A dictionary, a scientificdatabase,or a commercialdatabasecan contain billions ofentries; how can we sort such a large array?


Program 4.2.5 Doubling test for insertion sort

public class InsertionTest

{public static double timeTrials(int T, int N){ // Sort T random arrays of size N.

double total =0.0;Doubled a = new Double[N];for (int t = 0; t < T; t++){

for (int i = 0; i < N; i++)a[i] = Math.random();

Stopwatch watch = new Stopwatch();Insertion.sort(a);total += watch.elapsedTimeO;

}return total;

}public static void main(String[] args){ // Print doubling ratios for T trials of insertion sort

int T = Integer.parselnt(args[0]);double prev = timeTrials(T, 512);for (int N = 1024; true; N += N){

double curr = timeTrials(T, N);StdOut.printf(M%7d %4.2f\n", N, curr / prev);prev = curr;

}}

}

The method ti meTri al s () runs Inserti on. sort () for arrays ofrandom double values. Thefirst argument is the length of the array; the second is the number of trials. Multiple trialsproduce more accurate results because they dampen system effects and because insertion sorfsrunningtime depends on the input.

% Java InsertionTest 11024 0.71

2048 3.00

4096 5.20

8192 3.32

16384 3.91

32768 3.89

^"^^^^^^^^^^^^^^^^^^^s^^^^^^

Java InsertionTest 101024 1.89

2048 5.00

4096 3.58

8192 4.09

16384 4.83

32768 3.96

^^l^^^^^m^^^^^W^^^^W^^^^^^^^^S^^


Mergesort To develop a faster sorting method, we use recursion (as we did forbinary search) and a divide-and-conquer approach to algorithm design that everyprogrammer needs to understand. This nomenclaturerefers to the idea that one way to solve a problem is todivide it into independent parts, conquer them independently, and then use the solutions for the parts todevelop a solution for the full problem. Tosort an arraywith this strategy, we divide it into two halves, sort thetwo halves independently, and then merge the results tosort the full array. This method is known as mergesort.

We process contiguous subarrays of a given array,using the notation a[lo, hi) to refer to a[lo],a[l o+l],..., a [hi -1] (adopting the same convention as we used for binary searchto denote a half-open interval that excludesa [hi ]). Tosort a [1o, hi), we use thefollowing recursive strategy:

• Basecase: If the subarray size is 0 or 1, it is already sorted.• Recursive step: Otherwise, compute mi d = 1o + (hi - 1o)/2, sort (recur

sively) the two subarrays a [1o, mi d) and a [mi d, hi), and merge them.Merge (Program 4.2.6) is an implementation of this algorithm. The array elementsare rearranged by the code that follows the recursive calls, which merges the twohalves of the array that were sorted by the recursive calls. As usual, the easiest wayto understand the merge process is to study a trace of the contents of the array during the merge. The code maintains one index i into the first half, another index j

527

inputwas had him and you his the but

sort leftand had him was you his the but

sortrightand had him was but his the you

merge

and but had him his the was you

Mergesort overview

i j k aux[k]0 1 2 3 4 5 6 7

and had him was but his the you

0 4 0 and and had hi in wa s but his the you

1 4 1 but and had him was but his the you

1 5 2 had and had hi in was but his the you

2 5 3 him and had him was hut his the you

3 5 4 his and had hi in was but his the you

3 6 5 the and had him was hut h is the you

3 6 6 was and had him was but his the you

4 7 7 you and had him was but: his the you

Trace of the merge of thesorted lefthalfwith thesorted righthalf


Program 4.2.6 Mergesort

public class Merge

{public static void sort(Comparable[] a){ sort(a, 0, a.length); }

public static void sort(Comparable[] a, int lo, int hi){ // Sort a[lo, hi),

int N = hi - lo;if (N <= 1) return;int mid = lo + N/2;sort(a, lo, mid);sort(a, mid, hi);Comparable[] aux = new Comparable[N];int i = lo, j = mid;for (int k = 0; k < N; k++)

if (i == mid) aux[k] = a[j++];else if (j « hi) aux[k] = a[i++];else if (a[j].compareTo(a[i]) < 0) aux[k] = a[j++];else aux[k] = a[i++];

for (int k = 0; k < N; k++)a[lo + k] = aux[k];

}

public static void main(String[] args){ /* See Program 4.2.4 (and text) */ }

a[lo, hi)

N

mid

aux[]

subarray to sort

size of subarray

midpoint

extra arrayfor merge

}

The sort() function in this class is a fast method thatyou can use to sortarrays of any typeof data that implements Comparable. It is based on a recursive sort () thatsorts a [1o, hi)bysorting its two halves recursively then merging together the two halves to create thesortedresult. The output below andat right isa trace ofthe sorted subarrayfor each call tosort Q. Incontrast to Inserti on, this implementation issuitablefor sorting huge arrays.

java Merge < tiny.txtwas had him and you his the buthad was

and him

and had him was

his youbut the

but his the youand but had him his the was you

'•^Mmmmmmm mmmmmwm

nSWSH^^^^


into the second half, and a third index k into an auxiliary array aux [] that holds theresult. The merge implementation is a single loop that sets aux[k] to either a[i]or a [ j ] (and then increments k and the index for the value that is used). If either ior j has reached the end of its subarray, aux [k] is set from the other; otherwise, itis set to the smaller of a [i ] or a [ j ]. After all of the elements from the two halveshave been copied to aux[], the sorted result is copied back to the original array.Take a moment to study the trace just givento convinceyourself that this code alwaysproperly combines the two sorted subarrays to sort the full array.

The recursive method ensures that the two halves of the array are put intosorted order before the merge. Again, the best way to gain an understanding ofthis process is to study a trace of the contents of the array each time the recursiveso rt () method returns. Such a trace for our exampleis shown next. First a [0] anda[l] are merged to make a sorted subarray in a[0, 2), then a[2] and a[3] aremerged to make a sorted subarray in a [2, 4), then these two subarrays of size2 aremerged to make a sorted subarray in a[0, 4), and so forth. If you are convincedthat the merge works properly,you need only convinceyourself that the code properlydividesthe array to be convincedthat the sort worksproperly. Note that whenthe number of elements is not even, the left half will have one fewer element thanthe right half.

0 12 3 4 5 6 7

was had him and you his the but

sort(a, 0, 8)

sort(a, 0, 4)

sort(a, 0, 2)

return had was him and you his the but

sort(a, 2, 4)

return had was and him you the the but

return and had him was you the the but

sort(a, 4, 8)

sort(a, 4, 6)

return and had him was his you the but

sort(a, 6, 8)

return and had him was his you but the

return and had him was but his the you

return and but had him his the was you

Trace of recursive mergesort calls


Analysis of running time. Theinnerloopof mergesort is centered on the auxiliary array.The two f or loops involve N iterations (and creating the array takes timeproportional to N), so the frequency of execution of the instructions in the innerloop is proportional to the sum of the subarray sizes for all calls to the recursivefunction. The value of this quantity emerges when we arrange the calls on levelsaccording to their size.For simplicity, suppose that JV is a power of 2, with N = 2n.

On the first level, we have one call for size iV;1x N/i = n i ^^3 on the second level, we have two calls for2x n/2 = n i ji zi size N/2; on the third level, we have four4xjv/4 =n I ii n || I igN calls for size N/4; and so forth, down to the8xn/8 =n cUEOOJOJOJEJEJCn *" &* last level with N/2 calls of size 2. There are

preciselyn = IgiVlevels,giving the grand to-n/2 x 2 = n nnQD DDDD tal N IgiV for the frequency of execution ofTotal: Nign the instructions in the inner loop of merge-

Mergesort inner loop count (when Nis apower of2) sort This equation justifies a hypothesisthat the running time of mergesort is linearithmic. Note: When iVis not a power of

two, the subarrayson each level are not necessarily all the same size, but the number of levels is still logarithmic, so the linearithmic hypothesis is justified for all N(see Exercises 4.2.16-17).

You are encouraged to run a doubling test such as Program 4.2.5 for Merge.so rt O on your computer. If you do so,you certainlywill appreciate that it is muchfaster for large files than is Insertion.sort() and that you can sort huge arrayswith relativeease.Validatingthe hypothesis that the running time is linearithmic isa bit more work,but you certainlycan seethat mergesort makesit possiblefor us toaddresssorting problemsthat wecouldnot contemplatesolvingwith a brute-forcealgorithm such as insertion sort.

Quadratic-linearithmic chasm. The difference between N2 and NlgiV makes ahuge difference in practical applications, just the same as the linear-logarithmicchasm that isovercomebybinary search.Understanding theenormousness ofthis difference isanother critical step tounderstanding the importance ofthe design andanalysisofalgorithms. For a great many important computational problems, a speedupfrom quadratic to linearithmic—such as we achieve with mergesort—makes thedifferencebetween the ability to solve a problem involving a huge amount of dataand not being able to effectively address it at all.


Divide-and-conquer algorithms. Thesame basic approach is effective for manyimportant problems, as you will learn if you take a course on algorithm design.For the moment, you are particularly encouraged to study the exercises at the endof this section, which describe a host of problems for which divide-and-conqueralgorithms provide feasible solutions and which could not be addressed withoutsuch algorithms.

Reduction to sorting. A problem A reduces to a problem B if we can use a solution to B to solveA. Designing a new divide-and-conquer algorithm from scratchis sometimes akin to solving a puzzle that requires some experience and ingenuity,so you may not feelconfident that you can do so at first. But it is often the case thata simpler approach is effective: given a new problem that lends itself to a quadraticbrute-force solution, ask yourself how you would solve it if the data were sorted. Itoften turns out to be the case that a relatively simple linear pass through the sorteddata will do the job. Thus, we get a linearithmic algorithm, with the ingenuity hidden in the mergesort implementation. For example, consider the problem of determining whether the elements in an array are all different. This problem reducesto sorting because we can sort the array, and then pass through the sorted array tocheck whether any entry is equal to the next—if not, the elements are all different.For another example, an easy way to implement StdStats. sel ect () (see Section2.2) is to reduce selection to sorting. We consider next two more complicated examples, and you can find many others in the exercises at the end of this section.

Mergesort traces backto john von Neumann, an accomplished physicist,who wasamong the first to recognize the importance of computation in scientific research.Von Neumann made many contributions to computer science, including a basicconception of the computer architecture that has been used since the 1950s.Whenit came to applications programming, von Neumann recognized that:

• Sorting is an essential ingredient in many applications.• Quadratic algorithms are too slow for practical purposes.• A divide-and-conquer approach is effective.• Proving programs correct and knowing their cost is important.

Computers are many orders of magnitude faster and have many orders of magnitude more memory, but these basic concepts remain important today. People whouse computers effectively and successfully know, as did von Neumann, that brute-force algorithms are often not good enough to do the job.


Application: frequency counts FrequencyCount (Program 4.2.7) reads asequence of strings from standard input and then prints a table of the distinctvalues found and the number of times each was found, in decreasing order of thefrequencies. This computation is useful in numerous applications: a linguist mightbe studying patterns of word usage in long texts, a scientist might be looking forfrequently occurring events in experimental data, a merchant might be lookingfor the customers who appear most frequently in a long list of transactions, or anetwork analyst might be looking for the heaviest users. Each of these applicationsmight involvemillions of strings or more, so we need a linearithmic algorithm (orbetter). FrequencyCount is an example of developing such an algorithm by reduction to sorting. It actually does two sorts.

Computing thefrequencies. Our first stepisto sort the strings on standardinput.In this case, we are not so much interested in the fact that the strings are put intosorted order, but in the fact that sorting brings equal strings together. If the input is

to be or not to be to

then the result of the sort is

be be not or to to to

with equal strings, such as the two occurrences of be and the three occurrences ofto, brought together in the array. Now,with equal strings all together in the array,we can make a single pass through the array to compute all of the frequencies. TheCounter data type that we considered in Section 3.3 is the perfect tool for the job.Recall that a Counter has a string instance variable (initialized to the constructor argument), a count instance variable (initialized to 0), and an incrementOinstance method, which increments the counter by one. We maintain an array ofCounter objects and do the following for each string:

• If the string is not equal to the previous one, create a new Counter.• Increment the most recently created Counter.

At the end, the value of Mis the number of different string values, and zi pf [i ]contains the i th string value and its frequency.

Sorting the frequencies. Next, we sort the Counter objects by frequency. We cando so in client code without any special arrangements because Counter implements the Comparable interface (and therefore has a compareToO method). We


"\&.•4.-?

I1

'11

IS

i^^&^^^M

Program4.2.7 Frequency counts

public class FrequencyCount{

public static void main(String[] args){ // Print input strings in decreasing order

// of frequency of occurence.String s = Stdln.readAl1();String[] words = s.split("\\s+") ;Merge, sort (words);Counter[] zipf = new Counter[words.1ength];int M = 0;for (int i = 0; i < words.length; i++){ // Create new counter or increment prev counter,

if (i — 0 || !words [i]. equals (words [i-1]))zipf[M++] = new Counter(words[i], words.1ength);

zipf [M-l] .incrementQ;

}

}Merge.sort(zipf, 0, M);for (int j = M-l; j >= 0; j—)

StdOut.pri ntln(zi pf[j]);

This program sorts the words on standard input, uses the sorted list to count the frequency ofoccurrence ofeach, and then sorts the frequencies. The test file used below has over 20 millionwords. The plotcompares the i th frequency relative to thefirst (bars) with 1/i (blue)..

% Java FrequencyCount < LeipziglM.txt1160105 the

593492 of

560945 to

472819 a

435866 and

430484 in

205531 for

192296 The

188971 that

172225 is

148915 said

147024 on

141178 was

118429 by

I

!

^^^w^^^^^^s^^^^^^^^SSf^P^^I^K^^^^^^^^^

I

SSK^SE^CKaJsl^SsnS^


simply sort the array! Note that FrequencyCount allocates zipf [] to its maximum possible size and sorts a subarray, as opposed to the alternative of makingan extra passthrough words [] to determine the number of distinct entriesbefore

allocating zipf []. Leaving its recursive sort() functionfor subarrays public (there is not reason not to) allowsMergeSort to support such applications.

Zipfs law. The application highlighted in Frequency-Count is elementary linguistic analysis: which words appear most frequently in a text? A phenomenon known asZipfs law says that the frequency of the ith most frequentword in a text of M distinct words is proportional to 1/i,with its constant of proportionality the Harmonic numberHM. For example, the secondmost common word should

Counting the frequencies appear about half a$ often as ±e first This is an empiricalhypothesis that holds in a surprising variety of situations

rangingfrom financial data to webusage statistics. The test client run in Program4.2.7validates Zipfs lawfor a databasecontaining 1 million sen-tencesdrawn from popular publications (seethe booksite).

Youare likelyto find yourselfwriting a program sometime in thefuture for a simple task that could easily be solvedby first usinga sort. How many distinct valuesare there?Which value appearsmost frequently? Are the strings all different? Which is the median element?With a linearithmic sorting algorithm such as mergesort, you can address these problems and many other problemslike them, even for huge data sets. FrequencyCount, which usestwo different sorts, is a prime example. If sorting does not applydirectly, some other divide-and-conquer algorithm might apply, SortmZthefre1uenciesor some more sophisticated method might be needed. Without agood algorithm (and an understanding of its performance characteristics), you might find yourselffrustrated by the idea that your fast and expensive computer cannot solve a problemthat seems to be a simple one.With anever-increasing setof problemsthat youknowhowto solve efficiently, you willfindthat your computer can be a much more effective tool than you now imagine.Toillustrate this idea, we consider next an application to a problem in bioinformatics.

M a[1]zipf[i] .count0

i0 1 2 3

0

0 1 be 1

1 1 be 2

2 2 not •y 1

3 3 or 2 1 1

4 4 to 2 1 1 1

5 4 to 2 1 1 2

6 4 to 2 1 1 3

2 1 1 3

before0 2 be

1 1 not

2 1 or

3 3 to

after0 1 not

1 1 or

2 2 be

3 3 to


Application: longest repeated substring Another important computationaltask that reduces to sorting is the problemof finding the longest repeated substringin a given string. For example, the longest repeated substring in the string to beor not to be is the string to be. This problem is simple to state and has manyimportant applications, including data compression,cryptography, and computer-assistedmusic analysis. Think brieflyabout howyou might solve it. Could you findthe longest repeated substring in a string that has millionsof characters?

Another application is refactoring code. Programmersoften put together newprograms by cutting-and-pasting codefrom old programs.In a largeprogram builtover a long period of time, replacing duplicate code by function calls to a singlecopy of the code can make the program much easier to understand and maintain.This improvement can easily be accomplished by findinglong repeated substringsin the program. Documented success stories of using this approach on large systems have led to its being a standard technique in the repertoire of people whodevelop large software systems.

Another application is found in computational biology. Are substantial identical substrings to be found in a genome? Again, the basiccomputational problemunderlyingthis question is to find the longest repeated substringin a string. Scientists are typically interested in more detailed questions (indeed, the nature of therepeated substrings is preciselywhat scientistsseekto understand), but such questions are certainly no easier than the basic question of finding the longest repeatedsubstring. Various modifications of our solution to this problem can solve otherproblems of interest, as addressed in several of the exercises.

With such applications in mind, we now focus on the basic computationalproblem of finding the longest repeatedsubstring in a given string.

Longest common prefix. As a warm-up, consider the following simple task: giventwo strings, find their longest common prefix (the longest substring that is a prefixof both strings). For example, the longest common prefixof acctgttaac and ac-cgttaa is ace. The following code for solvingthis problem is a usefulstarting pointfor addressing more complicated tasks:


public static String lcp(String s, String t){

int N = Math.min(s.length() , t.lengthO);for (int i = 0; i < N; i++)

if (s.charAt(i) != t.charAt(i))return s.substring(0, i);

return s.substring(0, N);}

This code is trickier than it looks:you should convinceyourself that it works properlywhen the first charactersof the two strings are different,when one or both ofthe strings are of length 0, and the two cases when each of the strings is a prefix ofthe other.

Brute-force solution. Now, how do we find the longest sequence of charactersthat is repeated in a given string?With lcp(), the following brute-force solutionimmediately suggests itself:

public static String lrs(String s){

String Irs = "";for (int i = 0; i < N; i++)

{for (int j = i+1; j < N; j++){

String x = lcp(s.substring(i, N), s.substring(j, N));if (x.lengthO > Irs.lengthO)

Irs = x;

}}return Irs;

}

We compare the substring starting at each string position i with the substringstarting at each other starting position j, keepingtrack of the longest match found.This code is not useful for long strings, because its running time is at least quadraticin the length of the string: by examining the nested for loops, it is easy to see thatthe number of calls on 1cp() is N—1 + N—2 + ... + 2 + 1 ~ N2. Using this codefor a genomic sequencewith millions of characters would require trillions of 1cp()calls, which is infeasible.


Suffix sortsolution. The following clever approach, which again takes advantageof sorting in an unexpected way, is an effective way to find the longest repeatedsubsequence, evenin huge strings: weusesubstri ng() to makean arrayof stringsthat consists of the suffixes of s (the substrings startingat each position and going to the end), and then we sortthis array. The key to the algorithm is that every substring appears somewhere as a prefix of one of the suffixes in the array.Aftersorting, the longestrepeatedsubstrings will appear in adjacent positions in the array(like the equal keys in FrequencyCount). Thus, we canproceed just as we did for FrequencyCount: make a single pass through the sorted array, keeping track of thelongestmatchingprefixes between adjacent strings. LRS(Program 4.2.8) is an implementation of this method.This program is significantly more efficient than thebrute-force method. Analyzing its performancedependsupon an understanding of details of Java's Stri ng implementation, which we examine next. The end result isthat the running time is linearithmic (unless the lengthof the repeat is huge), and so we certainly can handlestrings with millions of characters.

String representation. The running time of LRS isstrongly dependent on the way that Java representsStri ng objects, so we briefly revisit the representation.A value of the St r i ng data type is a sequence of characters. Java represents them using an array of characters,plus the offset to the first character and the length. Aswith arrays, the implementationcanreturn the lengthinconstant time. Also, the string data type is immutable (ithas no methods to changeanystring'svalue),so Java canreuse the array holding the characters. In the presentcontext, the most important consequence of this designis that the substri ng() method does nottake time proportional to the length ofthe result,but instead requires just a few machine instructions: it simplycalculatesthe necessaryoffset to the first character and length in a straightforward manner.

inputstring012345678 91011121314

aacaagtttacaagc

suffixeso

1

2

3

4

5

6

7

8

9

10

11

12

13

14

aacaagtttacaagcacaagtttacaagccaagtttacaagcaagtttacaagcagtttacaagcgtttacaagctttacaagcttacaagct a c aa g ca c aa g cc aag ca ag cage

gcc

sorted suffixeso aacaagtttacaagc

n a a g c3 aagtttacaagc9 a c a a g ci acaagtttacaagc12 ag c4 agtttacaagc

14 C

io c a a g c2 caagtttacaagc13 g c5 gtttacaagc8 tacaagc7 ttacaagc6 tttacaagc

longest repeated substringl 9

aacaagtttacaagc

Computing theLRS bysortingsuffixes

538

288

311

407


Therefore, the substring operation in Java takes constant time and space. Javaprogrammers are well-advised to take advantage of this efficient implementation of

substringO.

288

|e—a.length mmm:.

407

311

462

12

459

ttt a

c aag

Hel 1

W

o r 1 d

stringobjects

"tttacaagc";'Hello, World"

311

407

iSl^-V.fV^W.TJ^.::

Ill

exch(a, 0, 1)

Exchanging twostrings in an array

Sorting strings. Given an array of strings,we can rearrange them so that they appearin lexicographic order in the array (the order they would appear in a dictionary) withMerge.sort() because String implements theComparabl e interface. It is very important to notethat this approach is effective for long strings andlarge objects because of the Java reference representation for objects: when weexchange two objects,weare exchanging onlyreferences, not thewhole object. Now, the cost of comparing two strings may beproportional to the length of the strings in the casewhen their common prefix is very long, but mostcomparisons in typical string sort applications involve only a few characters. If so, the running timeof the string sort is linearithmic.

Suffix arrays. From the standpoint of the sort,there is no difference between sorting an array ofstrings and sorting a suffix array: both refer to anarray of references to strings. A suffix array is anarray of string objects,each consistingof the standard object overhead, a reference to an array ofchar values,an offset,a length, (and a hash value).Suffix arrays are characterized by the fact that allof the array references are to the same char array,which holds the string of interest, and that eachpossible offset and length appears once.

LRS analysis. We cannowseewhythe suffix sorting approach to solving the longest repeated substring problem in Program 4.2.8is effective, even though the suffixes of a very long string are themselvesvery long.


ZW: i^mimmaaam^^Mmm^ismi^

:M

m

•x- ?•>•

fm

&£?&!

Program 4.2.8 Longest repeated substring

public class LRS

{public static String lcp(String s, String t){ // See text. }

public static String Irs(String s){ // Find the longest repeated substring in s.

// Create and sort suffix array.int N = s.lengthO ;String[] suffixes = new String[N];for (int i = 0; i < N; i++)

suffixes[i] = s.substring(i, N);Merge.sort(suffixes);

s

N

suffixes []

Irs

inputstring

length

suffixarray

longest repeatedsubstring

String Irs = "";for (int i = 0; i < N-l; i++){ // LRS is longest common prefix in adjacent strings.

String x = lcp(suffixes[i], suffixes[i+1]);if (x.length() > Irs.lengthO) Irs = x;

}return Irs;

}

public static void main(String[] args){ // Find the longest repeated substring in Stdln.

String s = Stdln.readAll();StdOut.println(lrs(s));

}

;«^s^:?PSW!iKP^^K!

}

To find the longest repeated substring in a string, we form an array ofall the strings suffixes,sort the array, andthen find the longest common prefix ofadjacent strings in the result.

% more example.txtaacaagtttacaagc

% Java LRS < example.txtacaag

% Java LRS < genome.txtaaactcgacaaacccatttaccccacactttt

Wg^^1m!!&^wz&&&&m& ^^$mW&^$&^^r%$^m^%i&


String s = "ATAGATGCATACCGCATAGCTAGATGTGCTAGCAT"int N = s.lengthO;String[] suffixes = new String[N];for (int i =0; i < N; i++)

suffixes[i] = s.substringO', N);

16 bytessuffixes []

Total: 16 + 4N + NX24 + 16 + 2N = 32 + 30N

16 bytes

2N bytes

Memory requirementsfor a suffix array

The total length of the suffixes is quadratic, but the actual space used is only linear,becauseJava representseach substringwith a constant amount of extra space. ThesubstringO operations all take constant time, most string comparisons involveonly a few character comparisons, and all exchanges are fast because they just involve exchanging references. In summary, this discussion supports the hypothesisthat the running time of Program 4.2.8 is linearithmic. We expect the sort to belinearithmic, and then we make a single pass through the string to find the longestcommon prefix among adjacent substrings.

Longrepeats. A more preciseanalysis showsthat our suffixsorting approach (andfinding the longest repeated substring) is quadratic (or worse) in the length of therepeated substring, because each suffixof the repeated substring appears twice as a


prefix in the suffixarray and requires time proportional to its length for 1cp() andfor comparisons during the sort. Accordingly, computational biologists and computer scientists have developed more sophisticatedalgorithms to look for repeated substrings whoselength is substantially longer than the square root ofthe string length.

Lessons The vast majority of programs that wewrite involvemanaging the complexity of addressinga new practical problem by developing a clear and correct solution, breaking the program into modules ofmanageable size whenever possible, and making useof the basic available resources. From the very start,our approach in this book has been to develop programs along these lines. But as you become involvedin ever more complex applications, you will find thata clear and correct solution is not always sufficient,because the cost of computation can be a limiting factor. The examples in this section are a basic illustration of this fact.

Respect the costof computation. If you can quicklysolve a small problem with a simple algorithm, fine.But if you need to address a problem that involves alarge amount of data or a substantial amount of computation, you need to takeinto account the cost.

input stringaacaagtttacaagc

suffixes of longest repeat (Mac aag

c aagaag

ag

g

--5)

all appearat leasttwiceas a prefixofa suffixstring

sortedsuffixes of inputaacaagtttacaagca a g caagtttacaagca c a a g cacaagtttacaagcageagtttacaagcc

c a a g ccaagtttacaagcgcgtttacaagct ac a ag cttacaagctttacaagc

comparison cost is at least1+2 + ...+M- M2/2

LRS costis quadratic in repeat length

Reduce to a known problem. Our use of sorting for frequency counting and forsolving the longest repeated substring problem illustrates the utility of understanding fundamental algorithms and using them for problem solving.

Divide-and-conquer. It is worthwhile for you to reflect a bit on the powerof thedivide-and-conquer paradigm, as illustrated by developing a logarithmic searchalgorithm (binary search) and a linearithmic sorting algorithm (mergesort) thatserves as the basis for addressing so many computational problems. Divide-and-conquer is but one approach to developing efficient algorithms.


Since the advent of computing, people have been developing algorithms such asbinary search and mergesort that can efficiently solvepractical problems. The fieldof study known as design and analysis of algorithms encompasses the study of design paradigms like divide-and-conquer, techniques to develop hypotheses aboutalgorithms performance, and algorithms for solving fundamental problems likesorting and searching that can be put to use for practical applications of all kinds.Implementations of many of these algorithms are found in Javalibraries or otherspecialized libraries, but understanding these basic tools of computation is likeunderstanding the basic tools of mathematics or science. You can use a matrix-processing package to find the eigenvaluesof a matrix, but you still need a coursein linear algebra. Now that you know that a fast algorithm can make the differencebetween spinning your wheels and properly addressing a practical problem, youcan be on the lookout for situations where algorithm design and analysis can makethe difference, and for efficient algorithms like binary search and mergesort thatcan do the job.


Q. Why do we need to go to such lengths to prove a program correct?

A. To spare ourselves considerable pain. Binary search is a notable example. Forexample, you now understand binary search; a classic programming exercise is towrite a version that uses a while loop instead of recursion. Try solving Exercise4.2.1 without looking back at the code in the book. In a famous experiment, JonBentleyonce asked several professional programmers to do so, and most of theirsolutions were not correct.

Q. Are there implementations for sorting and searchingin the Java library?

A. Yes. The Javalibrary Java, util .Arrays contains the methods Arrays, sort ()and Arrays.binarySearchO that implement mergesort and binary search forComparable types and a sorting implementation for primitive types based on aversion of the quicksort algorithm, which is faster than mergesort and also sorts anarray in place (without using any extra space).

Q. So why not just use them?

A. Feelfree to do so. As with many topics we have studied, you will be able to usesuch tools more effectively if you understand the background behind them.

Q. Why do I get a unchecked or unsafe operation warning when compiling Insertion and Merge?

A, The argument to sort() is a Comparable array, but nothing, technically, prevents its elements from being of differenttypes.Toeliminate the warning, changethe signature to:

public static <Key extends Comparable<Key» void sort(Key[] a)

We'll learn about the <Key> notation in the next section.


4.2.1 Develop an implementation of TwentyQuesti ons that takes the maximumnumber N as command-line argument. Prove that your implementation is correct.

4.2.2 Add code to Inserti on to produce the trace given in the text.

4.2.3 Add code to Merge to produce the trace givenin the text.

4.2.4 Give traces of insertion sort and mergesort in the styleof the traces in thetext, for the input i t was the best of times it was.

4.2.5 Describe whyit is desirable to use immutable keys with binary search.

4.2.6 Explain whywe use 1o + (hi - 1o) / 2 to compute the index midwaybetween lo and hi instead of using (lo + hi) / 2.

Answer: The latter fails when 1o + hi overflows an i nt.

4.2.7 Modify Bi narySearch (Program 4.2.3) so that if the search key is in thearray, it returns the smallest index i for which a [i ] is equal to key, and otherwise,it returns -i, where i is the smallest index such that a [i ] is greater than key.

4.2.8 Describe what happens if you apply binary search to an unorderd array.Why shouldn't you check whether the array is sorted before each call to binarysearch? Couldyou checkthat the elements binary searchexamines are in ascendingorder?

4.2.9 Write a program DeDup that reads strings from standard input and printsthem on standard output with all duplicates removed (and in the same order theyare found in the input).

4.2.10 Find the frequency distribution of words in your favorite book. Does itobey Zipf's law?

4.2.11 Find the longest repeated substring in your favorite book.

4.2.12 Add code to LRS (Program 4.2.8) to make it print indices in the originalstring where the long repeated substring occur.


4.2.13 Find a pathological input for which LRS (Program 4.2.8) runs in quadratictime (or worse).

4.2.14 Showthat binary search in a sorted array is logarithmic as long as it eliminates at least a constant fraction of the array at each step.

4.2.15 Modify BinarySearch (Program 4.2.3) so that if the search key is not inthe array, it returns the largest index i for which a[i ] is smallerthan key (or -1 ifno such index exists).

4.2.16. Analyze mergesort mathematicallywhen N is a power of 2, as we did forbinary search.

Answer: Let M(N) be the frequency of execution of the instructions in the innerloop. Then M(N) must satisfy the followingrecurrence relation:

M(N) = 2M(N/2) + N

with M(l) = 0. Substituting 2" for AT gives

M(2»)=2M(2""1)+ 2"

which is similar to but more complicated than the recurrence that we consideredfor binary search. But if we divide both sidesby 2",we get

M(2»)/ 2" = M(2»-!)/ 2""1 4- 1

which is precisely the recurrence that we had for binary search. That, is M(2n)/ 2n= T(2") = n. Substituting back N for 2n (and IgN for n) gives the result M(N) =NlgN.

4.2.17 Analyze mergesort for the casewhen N not a power of two.

Partial answer: When N is an odd number, one subarray has to have one moreentry than the other, so when N is not a powerof two,the subarrayson each levelare not necessarilyall the same size. Still,everyelement appears in some subarray,and the number of levelsis still logarithmic, so the linearithmic hypothesis is justified for all N.

545


XIreatiMMSEx&iiBiltes

Thefollowing exercises are intended to give youexperience indevelopingfastsolutionstotypical problems. Think about using binary search, mergesort, ordevisingyour owndivide-and-conquer algorithm. Implement andtestyouralgorithm.

4.2.18 Median. Add to StdStats a method medi an () that computes in linearithmic time the median of a sequence of N integers. Hint:Reduce to sorting.

4.2.19 Mode. Add to StdStats a method mode() that computes in linearithmictime the mode (value that occurs most frequently) of a sequence of JV integers.Hint: Reduce to sorting.

4.2.20 Integer sort. Write a linear-time filter that takes from standard input a sequence of integers that are between0 and 99 and prints the same set of integers insorted order on standard output. For example, presented with the input sequence

98 2310003 98 98 2220002

your program should print the output sequence

00000012222233 98 98 98

4.2.21 Floor and ceiling. Given a sorted array of Comparabl e items, write methods f 1oor () and cei 1() that returns the indexof the largest (or smallest) item notlarger (or smaller) than an argument item in logarithmic time.

4.2.22 Closest pair. Given an array of JV real numbers, write a static method tofind in linearithmic time the pair of integersthat are closestin value.

4.2.23 Furthest pair. Given an array of AT real numbers, write a static method tofind in linear time the pair of integers that are farthest apart in value.

4.2.24 Two sum. Write a static method that takes as argument an array of JV i ntvaluesand determines in linearithmic time whether any two of them sum to 0.

4.2.25 Three sum. Writea staticmethod that takesas argument an array of JV intvalues and determines whether any three of them sum to 0. Yourprogram shouldrun in time proportional to JV2 log N. Extra credit Develop a program that solvesthe problem in quadratic time.


4.2.26. Majority. An element is a majority if it appearsmore than JV/2 times.Writea static method that takes an array of JV strings as argument and identifiesa majority (if it exists) in linear time.

4.2.27 Common element. Write a static method that takes as argument three arraysof strings, determines whether there is any string common to all three arrays,and if so, returns one such string. The running time of your method should belinearithmic in the total number of strings.

4.2.28 Prefix-free codes. In data compression, a set of strings is prefix-free if nostring is a prefixof another. For example, the set of strings01,10,0010, and 1111are prefix-free, but the set of strings 01,10, 0010,1010 is not prefix-free because10 is a prefix of 1010.Write a program that reads in a set of strings from standardinput and determines whether the set is prefix-free.

4.2.29 Longest common substring. Write a static method that finds the longestcommon substring of two given strings s and t.

4.2.30 Longest repeated, non-overlapping string. Modify LRS (Program 4.2.8) tofind the longest repeated substring that does notoverlap.

4.2.31 Partitioning. Write a static method that sorts a Comparable array that isknown to have at most two different values. Hint: Maintain two pointers, one starting at the left end and movingright, the other startingat the right end and movingleft. Maintain the invariant that all elements to the left of the left pointer are equalto the smaller of the two values and all elements to the right of the right pointer areequal to the larger of the two values.

4.2.32 Dutch national flag. Write a static method that sorts a Comparable arraythat isknown to haveat most three differentvalues. (EdsgarDijkstra named this theDutch-national-flag problem because the result is three"stripes" of values like thethree stripes in the flag.) Hint:Reduce to the previousproblem,by first partitioningthe array into two parts with allelements having the smallest valuein the first partand all other elements in the second part, then partition the second part.

547


4.2.33 Quicksort. Write a recursive program that sorts an array of randomly ordered distinct Comparabl e elements. Hint: Use a method like the one described inthe previous exercise. First,partition the array into a left part with all elementslessthan v,followed byv,followed bya right part with allelementsgreaterthan v.Then,recursively sort the two parts. Extra credit: Modifyyour method (if necessary) towork properly when the elementsare not necessarily distinct.

4.2.34 Reverse domain. Write a program to read in a list of domain names fromstandard input and print the reverse domain names in sorted order. For example,the reverse domain of cs. pri nceton.edu is edu. pri nceton. cs. This computation is useful for web log analysis. Todo so, create a data type Domai n that implements the Comparabl e interface,using reversedomain name order.

4.2.35 Local minimum in an array. Given an array of JV real numbers, write astatic method to find in logarithmic time a local minimum (an index i such thata[i-l] <a[i] <a[i+l]).

4.2.36 Discrete distribution. Design a fast algorithm to repeatedlygenerate numbers from the discrete distribution:Given an arraya [] of nonnegativerealnumbersthat sum to 1,the goalis to return index i with probability a [i ]. Form an array s []of cumulated sums such that s [i ] is the sum of the first i elements of a []. Now,generatea random realnumber r between0 and 1,and use binary searchto returnthe index i for which s[i] < r < s [i +1].

4.2.37 Rhyming words. Tabulate a list that you can use to findwords that rhyme.Use the following approach:

• Readin a dictionary of words into an array of strings.• Reverse the letters in eachword (confound becomesdnuofnoc, for example).• Sort the resulting array.• Reverse the letters in eachword back to their original order.

For example, confound is adjacent to words such as astound and surround in theresulting list.


4.3 Stacks and Queues

In this section, we introduce two closelyrelated data types for manipulating arbitrarily large collections of objects: the stack and the queue. Stacks and queues arespecial cases of the idea of a collection. Acollection of objects is characterized byfour operations: create the collection, in- 4.3.1 Stack ofstrings (array) 554sert an object, remove an object, and test 43'2 ^ack ofstrings (linked list).. 559

l. ^ ^ ii ^ ^ 4.3.3 Stack of strings (array doubling). , 563whether the collection is empty. 434 Generk stack* ...;..;./*.. 568When we insert an object, our in- 43.5 Expression evaluation 572

tent is clear. But when we remove an ob- 4.3.6 Generic FIFO queue (linked list). . 578ject, which onedo we choose? Each type 4-3-7 M/D/1 <lueue simulation 583of collection is characterized by the rule 4'3'8 Load balancing simulation 591used for remove, and each is amenable Programs inthis sectionto various implementations with differing performance characteristics.You haveencountered different waysto answerthis question in various real-world situations,perhaps without thinking about it.

For example, the rule used for a queue is to always remove the item that hasbeen in the collectionthe most amount of time. This policyisknown asfirst-infirst-out, or FIFO.Peoplewaiting in line to buy a ticket followthis discipline: the line isarranged in the order of arrival, so the onewho leaves the line has been there longerthan any other person in the line.

A policywith quite differentbehavior is the rule used for a stack: always remove the item that has been in the collection the least amount of time. This policyis known as last-in first-out, or LIFO. For example, you follow a policy closer toLIFO when you enter and leave the coach cabin in an airplane: people near thefront of the cabin board last and exit before those who boarded earlier.

Stacks and queues are broadly useful,so it is important for you to be familiarwith their basic properties and the kind of situation where each might be appropriate. They are excellent examples of fundamental data types that we can use toaddress higher-level programmingtasks. Theyare widely used in systems and applications programming, as we will see in several examples in this section and inSection 4.5.


Pushdown stacks Apushdown stack (or just a stack) is a collection that is basedon the last-in-first-out (LIFO) policy.

When you keep your mail in a pile on your desk,you are using a stack.Youpile pieces of new mail on the top when they arrive and take each piece of mail from the top whenyou are ready to read it. People do not process asmany papers as they did in the past, but the sameorganizing principle underlies severalof the applications that you use regularly on your computer.For example, many people organize their email asa stack, where messages go on the top when theyare received and are taken from the top, with mostrecently received first (last in, first out). The advantage of this strategy is that we see interestingemail as soon as possible; the disadvantage is thatsome old email might never get read if we neverempty the stack.

You have likely encountered another common example of a stack when surfing the web.When you click a hyperlink, your browser displaysthe new page (and inserts it onto a stack). You cankeep clicking on hyperlinks to visit new pages,butyou can always revisit the previous page by clicking the back button (remove it from a stack). Thelast-in-first-out policy offered by a pushdownstack provides just the behavior that you expect.

Such uses of stacks are intuitive, but perhapsnot persuasive. In fact, the importance of stacksincomputing is fundamental and profound, but wedefer further discussions of applications to later inthis section. For the moment, our goal is to makesure that you understand how stacks work andhow to implement them.

Stacks have been used widelysince the earliest days of computing. By tradition, we name the stack insert operation push and the stack remove operation pop,as indicated in the following API:

a stack ofdocuments N^

push(

push(.

popO

^mmr = popO

551

new (gray)onegoes on top

new (black) on>goes on top

remove theblack one

from thetop

remove thegray one

from thetop

Operations on a pushdown stack


public class *StackOfStrings

*StackOfSt ri ngs () create anempty stack

bool ean i sEmpty () isthe stack empty?

void push (St ring item) push a string onto the stack

St ri ng pop () pop the stack

APIfor a pushdown stackfor strings

The asterisk indicates that we will be considering more than one implementationof this API (we consider three in this section: ArrayStackOfStri ngs, Linked-StackOfSt ri ngs, and Doubli ngStackOfSt ri ngs). This API also includes a method to testwhetherthe stackisempty,leaving to the clientthe responsibility ofusingi sEmpty() to avoidinvoking popO when the stackis empty (an alternative designwould be to throw an exception in that case).

This API has an important restriction that is inconvenient in applications:we would like to have stacks that contain other types of data, not just strings. Weexamine ways to remove this restriction (and the importance of doing so) later inthis section.

Array implementation Representing stacks with arrays is a natural idea, butbefore reading further, it is worthwhile for you to think for a moment about howyou would implement a class ArrayStackOfStri ngs.

The first problemthat you might encounteris implementing the constructorArrayStackOfStri ngs(). You clearly need an instancevariable a[] with an arrayof strings to hold the stackitems,but how big should the array be? One solution isto startwith an array of size0 and make surethat the array size is always equal tothe stack size, but that solution necessitates allocating a new array and copying allof the itemsinto it for each push () and pop () operation, whichisunnecessarily inefficientand cumbersome.We will temporarily finesse this problem by having theclient provide an argument for the constructorthat gives the maximum stack size.

Your next problemmight stem fromthe naturaldecision to keep the items inthe array in the orderthey appear on the stack, with the top element in a[0], thesecondelement in a[1], and so forth. But then eachtime you push or pop an item,you would have to move all of the other items to reflect the new state of the stack.A simpler and more efficientwayto proceed is to keep the items in reverse orderof


their arrival, as illustrated. This policy allowsus to add and remove items at the endwithout moving any of the other items in the stack.

We could hardly hope for a simpler implementation of the stack API thanArrayStackOfSt rings (Program 4.3.1)—all of the methods are one-liners! Theinstance variables are an array a [] that hold the items in the stack and an integer Nthat counts the number of items in the stack. To remove an item, we decrement Nand then return a [N]; to insert a new item, we set a [N] equal to the new item andthen increment N. These operations preservethe following properties:

• The items in the array are intheir insertion order.

• The stack is empty when Nis 0.• The top of the stack (if it is

nonempty) is at a [N-l].Asusual, thinking in terms of invariants of this sort is the easiest way toverify that an implementation operates as intended. Be sure that youfully understand this implementation.Perhaps the best way to do so is tocarefully examine a trace of the stackcontents for a sequence of push()and popO operations. The test client in Stri ngStackArray allows fortesting with an arbitrary sequence ofoperations: it does a push() for eachstring on standard input except thestring consisting of a minus sign, forwhich it does a pop().

The primary characteristic of this implementation is that thepushandpopoperations take constant time. The drawback of this implementation is that it requiresthe client to estimate the maximum sizeof the stack ahead of time and always usesspace proportional to that maximum, which may be unreasonable in some situations. We omit the code in push () to test for a full stack, but later we will examineimplementations that address these drawbacksby not allowingthe stack to get full(except in an extreme circumstance when there is no memory at all available foruse by the Java system).

a[]Stdln StdOut N

0 1 2 3 4

0

to 1 to

be 2 to be

or 3 to be or

not 4 to be or not

to 5 to be or not to

- to 4 to be or not to

be 5 to be or not be

- be 4 to be or not be

- not 3 to be or not be

that 4 to be or that be

- that 3 to be or that be

- or 2 to be or that be

- be 1 to be or that be

is 2 to is or not to

Trace o/ArrayStackOfStri ngs testclient

553


in

w

mmm

if

HI

itmi

Program 43.1 Stackofstrings (array)

public class ArrayStackOfStrings{

private String[] a;private int N = 0;

public ArrayStackOfStrings(int max){ a = new String[max]; }

public boolean isEmptyO{ return (N ==0); }

public void push(String item){ a[N++] = item; }

public String popO{ return a[--N]; }

public static void main(String[] args){ // Create a stack of capacity max

// and push or pop strings as directed on Stdln.int max = Integer.parselnt(args[0]);ArrayStackOfStrings s = new ArrayStackOfStrings(max);while (!Stdln.isEmptyO)

{String item = Stdln. readStringO;if (litem.equalsC'-"))

s.push(item);else

StdOut.pri nt(s.popO);

}}

a[]

N

N-l

stack values

number of items

indexof valuemost recently pushed

'^^^^^^^^^^^^Pl

Stack methods aresimple one-liners, as illustrated in this code. The clientpushes orpopsstringsas directed from standard input (a minus sign indicates pop, and any other string indicatespush). Codein push () to testwhether thestack isfull is omitted (see text).

% more tobe.txt

to be or not to - be

Java ArrayStackOfStrings 5 < tobe.txtto be not that or be

4.3 Stacks and Queues 555

Linked lists For classes such as stacks that implementcollections of objects, animportant objective is to ensure that the amount ofspace used isalways proportionalto thenumber of items in thecollection. The use of a fixed-size array to implementstacks in ArrayStackOfSt rings works against this objective: when you create ahuge stack, you are wasting a potentially huge amount of memory at times whenthe stack is empty or nearly empty. This property makes the array implementationunusable in applications involving large numbers of items moving among largenumbers of stacks, which are typical. For example, a transaction system might involvebillions of items and thousands of collectionsof them. Wemight not be ableto afford the memory to allow for the possibility that each of those collectionscould each hold all of those items. Worse, if all of the items do wind up in onecollection, we know that the others would all be empty, so that wasted memory isunnecessary. One of the primary purposes of Java's memory allocation system isto provide the flexibility to handle such situations. Now we consider the use of afundamental data structure known as a linked UsU which can provide implementations of collections (and, in particular, stacks) that achievethe objective cited at thebeginning of this paragraph.

A linked list is a recursive data structure defined as follows: it is either empty(null) or a reference to a node having a reference to a linked list. The node in thisdefinition is an abstract entity that might hold any kind of data, in addition to thenode reference that characterizes its role in building linked lists.Aswith a recursiveprogram, the concept ofa recursive data structure can be a bit mindbending at first,but is of great value because of its simplicity.

With object-oriented programming, implementing linked lists is not difficult.We start with a class for the node abstraction:

class Node

{String item;Node next;

}

A Node has two instance variables: a String and a Node. The String is a placeholder in this example for any data that we might want to structure with a linkedlist (we can use any set of instance variables); the instance variable of type Nodecharacterizes the linked nature of the data structure. To emphasize that we are justusing the Node class to structure the data, we define no methods. Now, from the recursive definition, we can represent a linked list with a variable of type Node simply


by ensuring that its value is either nul1 or a reference to a Node whose next field isa reference to a linked list.

As with any type of data, we create an object of type Node by invoking the(no-argument) constructor with new Node(). The result is a reference to a Nodeobject whose instance variablesare both initialized to the value null.

For example, to build a linked list that contains the items to, be, and or, wecreate a Node for each item:

Node first = new Node();

first.item = "to";

f i rst

Node first = new Node();Node second = new Node();Node third = new Node();

and set the i tern field in each of the nodes

to the desired value:Node second = new Node();

first.item = "to"; second.item = "be";second.item = "be"; first.next = second;third.item = "or";

f i rst

and set the next fields to build the linked

list:

first.next = second;second.next = third;

As a result, thi rd is a linked list (it is a reference to a node that contains null, which

is the null reference to an empty linkedlist), and second is a linked list (it is a reference to a node that has a reference to

thi rd, which is a linked list), and f i rst isa linked list (it is a reference to a node thathas a reference to second, which is a linkedlist). The code that we will examine does these assignment statements in a differentorder, depicted in the diagram on this page.

A linked list represents a sequence of items. In the example just considered,f i rst represents the sequence to be or. We can also use an array to represent asequence of items. For example, we could use

String[] s = { "to", "be", "or" };

second

Muawwatm&t

i"TT i1 null |

Node third = new Node();third.item = "or";

second.next = third;

second

thi rd

Linking together a list


save a link to the list

Node oldfirst = first;

oldfirst

first

create a newnodefor thebeginning

first = new Node();

oldfi rst

fi rst -

set the instance variables in the new node

first.item = "not";

first, next = oldfirst;

first

557

to represent the same sequence ofstrings. The difference is that it is easierto insert items into the sequence and toremove items from the sequence withlinked lists. Next, we consider code toaccomplish these tasks.

When tracing code that uses linkedlists and other linked structures, we usea visual representation where:

• We draw a rectangle to representeach object.

• We put the values of instance variables within the rectangle.

• We use arrows that point to the referenced objects to depict references.

This visual representation captures theessential characteristic of linked lists.

For economy, we use the term links torefer to node references. For simplicity,when item values are strings (as in ourexamples), we put the string within theobject rectanglerather than the more accuraterendition depictingthe string objectand the character array that we discussed in Section 4.1. (If you work Exercise4.3.12, you will better understand the precise representation of linked lists with

Inserting a newnode at thebeginning ofa linked list

first = first.next;

first

first

Removing thefirst node in a linked list

string items in Java.) This visual representationallows us to focus on the links.

Suppose that you want to inserta new nodeinto a linked list. The easiest place to do so is atthe beginning of the list. For example, to insertthe string not at the beginning of a given linkedlist whose first node is f i rst, we save f i rst inoldfi rst, assign to fi rst a new Node, and assign its item field to not and its next field tooldfirst.

Suppose that you want to remove the first node from a list. This operation iseven easier: simply assign to f i rst the value f i rst. next. Normally, you would


retrieve the value of the item (byassigningit to some String variable) before doingthis assignment,because onceyou changethe value of f i rst, you may not haveanyaccess to the node to which it was referring. Typically, the node object becomes anorphan, and the memory it occupies is eventually reclaimed by the Java memorymanagement system.

This code for inserting and removing a node from the beginning of a linkedlist involves just a few assignment statements and thus takes constant time (independent of the length of the list). If you hold a reference to a node at an arbitraryposition in a list, you can use similar (but more complicated) code to remove thenode after it or to insert a node after it, also in constant time. However, we leavethose implementations for an exercise (see Exercise 4.3.25-26) because insertingand removing at the beginning are the only linked-list operations that we need inorder to implement stacks.

Implementing stacks with linked lists. LinkedStackOfStri ngs (Program4.3.2)uses a linked list to implement a stack of strings, using little more code than theelementary solution that uses arrays.

The implementation is based on a nested classNode like the one we havebeenusing. Java allows us to define and use other classes within class implementationsin this natural way. The class is private because clients do not need to know anyof the details of the linked lists. One characteristic of a private nested class is thatits instance variables can be directly accessed from within the enclosing class butnowhere else, so there is no need to declare the Node instance variables as publ i cor private.

LinkedStackOfStrings itself has just one instance variable: a reference tothe linked list that represents the stack. That single link suffices to directly accessthe item at the top of the stack and also provides access to the rest of the items inthe stackfor push() and pop(). Again, be sure that you understand this implementation—it is the prototype for several implementations using linked structures thatwe will be examining later in this chapter. Using the abstract visual list representation to trace the code is the best way to proceed.

Linked list traversal. One of the most common operations weperform on collections is to iterate through the items in the collection.For example,we might wish toimplement the toStri ng() method that is inherent in every JavaAPI to facilitatedebugging our stack code with traces. For ArrayStackOfSt ri ngs, this implementation is familiar.


&M^Ms£Jfc^^^

Program 43.2 Stack ofstrings (linked list)

public class LinkedStackOfStrings{

private Node first;

private class Node

{String item;Node next;

}

public boolean isEmptyO{ return (first == null); }

public void push(String item){ // Add item to top of stack.

Node oldfirst = first;first = new Node();first.item = item;first,next = oldfirst;

}

public String popO{ // Remove item from top of stack.

String item = first.item;first = first, next;return item;

}


LinkedStackOfStrings s = new LinkedStackOfStringsO;// See Program 4.3.1 for the test client.

}

item

next

559

list item

next node on list

This stack implementation uses a private nested class Node as the basis for representing thestack as a linked list of Node objects. The instance variable fi rst refers to thefirst (most recently inserted) Node on thelist. The next instance variable in each Node refers to thenextNode(the value of next in thefinal node is nul 1). No explicit constructors are needed, because Javainitializes the instance variables to null.

V^!^!^^

% Java LinkedStackOfStrings < tobe.txtto be not that or be

560

Stdln

to

be

or

not

to

be

that

is


StdOut

to

be

not

that

or

be

Trace of LinkedStackOfStrings testclient




s += a[i] + " ";return s;

}

As usual, this solution is intended for use only when Nis small—it takes quadratictime because string concatenation takeslinear time. Our focus now is just on theprocess of examining everyitem. There is acorresponding idiom for visiting the itemsin a linked list: We initialize a loop indexvariable x that references the first Node of

the linked list. Then, we find the value ofthe item associated with x by accessingx. i tern, and then update x to refer to thenext Node in the linked list, assigning to itthe value of x.next and repeating thisprocess until x is null (which indicatesthat we have reached the end of the linked

list). This process is known as traversingthe list, and is succinctly expressed in thisimplementation of toStringO forLi nkedStackOfStri ngs:


String s = "";for (Node x = first; x

s += x.item + " ";return s;

}

x =

x =

Traversing a linked list

!= null; x = x.next)

When you program with linked lists, this idiom will become as familiar to you asthe standard idiom for iterating through the items in an array. At the end of thissection, we consider the concept of an iterator, which allows us to write client codeto iterate through the objects ofa collection without having to program at this levelof detail.

561


With a linked-list implementation we can write client programs that use large numbers of stackswithout havingto worrymuch about spaceusage. The sameprincipleappliesto collections of data of anysort, so linkedlistsare widelyused in programming. Indeed, typical implementations of the Java memory management systemare based on maintaining linked lists corresponding to blocks of memory of various sizes. Before the widespreaduse of high-level languages like Java, the details ofmemory management and programmingwith linkedlistswasa criticalpart of anyprogrammer's arsenal. In modern systems, most of these details are encapsulatedin the implementations of a fewdata types like the pushdown stack, including thequeue, the symbol table, and the set, which we will consider later in this chapter.If you take a course in algorithms and data structures, you will learn several others and gain expertisein creatingand debugging programs that manipulate linkedlists. Otherwise, you can focus your attention on understanding the role playedby linked lists in implementing these fundamental data types. For stacks, they aresignificant because they allow us to implement the push() and pop() methodsin constant time while using only a small constant factor of extra space (for thelinks).

Array doubling Next, we consideran alternative approach to accommodatingarbitrary growth and shrinkage in a data structure that is an attractive alternativeto linked lists. Aswith linked lists,we introduce it now because the approach is notdifficult to understand in the context of a stack implementation and because it isimportant to know when addressing the challenges of implementing data typesthat are more complicated than stacks.

The idea is to modify the array implementation to dynamically adjust the sizeof the array a [] so that it isboth sufficientlylarge to hold all of the items and not solarge as to waste an excessive amount of space.Achievingthese goals turns out to beremarkably easy, and we do so in Doubl i ngStackOfStri ngs (Program 4.3.3).

First, in push(), we check whether the array is too small. In particular, wecheck whether there is room for the new item in the array by checking whether thestack size Nis equal to the array size a. 1ength. If there is room, we simply insertthe new item with the code a [N++] = i tern as before; if not, we double the size of the

array by creating a new array of twice the size, copying the stack items to the newarray, and resetting the a[] instance variable to reference the new array.

Similarly, in pop(), we begin by checking whether the array is too large, andwe halve its size if that is the case.If you think a bit about the situation, you will see


m

0,m

P

*?%

1M

Program 4.3.3 Stack ofstrings (array doubling)

public class DoublingStackOfStrings{

private String[] a = new String[l];private int N = 0;

public boolean isEmptyO{ return (N ==0); }

private void resize(int max){ // Move stack to a new array of size max.

String[] temp = new String[max];for (int i = 0; i < N; i++)

temp[i] = a[i];a = temp;

}

public void push(String item){ // Add item to top of stack.

if (N == a.length) resize(2*a.length);a[N++] = item;

}

public String pop(){ // Remove item from top of stack.

String item = a[--N];a[N] = null; // Avoid loitering (see text).if (N > 0 && N — a.length/4) resize(a.length/2);return item;

}


DoublingStackOfStrings s = new DoublingStackOfStrings();// See Program 4.3.1 for the test client.

}}

a[]

N

stack items

number of itemsi

This implementation achieves theobjective ofsupporting stacks of anysizewithoutexcessivelywasting space bydoubling thesizeofthe array whenfull andhalving thesizeofthearray tokeepit always at least one-quarterfull Onaverage, all operations areconstant-time (see text).

Java DoublingStackOfStrings < tobe.txtto be not that or be

*%^s^ss^s^^*^SP^^^fci^Kl»«^^^^


Stdln StdOut N a.length0 1 2 3 4 5 6 7

0 1 null

to 1 1 to

be 2 2 to be

or 3 4 to be or null

not 4 4 to be or not

to 5 8 to be or not to null null null

- to 4 8 to be Of not null null null null

be 5 8 to be or not be null null null

- be 4 8 to be or not null null null null

- not 3 8 to be or null null mill n'iU null

that 4 8 to be or that null mill null null

- that 3 8 to be o r null null null null null

- or 2 4 to be null null

- be 1 2 to null

is 2 2 to is

Trace of Doubl i ngStackOfStri ngs test client

that the appropriate test is whether the stack size is less than one-fourth the arraysize.Then, after the array is halved, it willbe about half full and can accommodatea substantial number of push() and pop() operations before having to changethe sizeof the array again.This characteristic is important: for example, if we wereto use to policy of halving the array when the stack size is one-half the array size,then the resulting array would be full,which would mean it would be doubled for apush(), leading to the possibilityof an expensive cycle of doubling and halving.

Amortized analysis. This doubling and halving strategy is a judicious tradeoffbetween wasting space (by setting the size of the array to be too big and leavingempty slots) and wasting time (by reorganizing the array after each insertion).The specific strategy in Doubli ngStackOfSt ri ngs guarantees that the stack neveroverflows and never becomes less than one-quarter full (unless the stack is empty,in which case the array sizeis 1). If you are mathematically inclined, you might enjoy proving this fact with mathematical induction (see Exercise 4.3.20). More important, we can prove that the cost of doubling and halving is alwaysabsorbed (towithin a constant factor) in the cost of other stack operations. Again, we leave thedetails to an exercise for the mathematically inclined, but the idea is simple: when


push() doubles the sizeof the array to sizeN, it starts with N/2 items in the stack,so the size of the arraycannot doubleagain at until the clienthas made at leastN/2additional calls to push() (more if there are some intervening calls to popO). Ifweaverage the costof the push() operation that causes the doublingwith the costof those N/2 push() operations, we get a constant. In other words, in Doubl i ngStackOfSt ri ngs, the total cost ofallofthe stack operations divided by the number ofoperations is bounded by a constant. Thisstatement is not quite as strong as sayingthat each operationis constant-time, but it hasthe same implications in manyapplications (for example, when our primaryinterest is in total running time). Thiskind of analysis is known as amortized analysis—array doubling is a prototypicalexample of its value.

Orphaned items. Java's garbage collection policy isto reclaim the memoryassociatedwith anyobjects that can no longerbe accessed. In the pop() implementationin our initial implementationArrayStackOfSt ri ngs, the reference to the poppeditem remainsin the array. The itemisan orphan—we willneveruse it againwithinthe class, either because the stack will shrink or because it will be overwritten with

another reference if the stack grows—but the Java garbage collector has no way toknow this. Even when the client is done with the item, the reference in the arraymaykeep it alive. Thiscondition(holding a reference to an itemwhichisno longerneeded) is known as loitering, whichis not the sameas a memory leak (whereeventhe memory management system has no referenceto the item). In this case,loitering is easy to avoid. The implementation of pop() in Doubl ingStackOfSt ringssets the array entry corresponding to the popped item to null, thus overwritingthe unusedreference and making it possible for the system to reclaim the memoryassociatedwith the popped item when the client is finished with it.

With an array-doubling implementation (aswith a linked-list implementation), wecanwrite clientprogramsthat uselargenumbersof stacks without havingto worrymuch about space usage. Again, the same principle applies to collections of dataof anysort. Forsomedata types that aremorecomplicated than stacks, arraydoublingis preferredoverlinkedlistsbecause the ability to access anyitem in the arrayin constant time (through indexing) is criticalfor implementing certain operations(see, for example, RandomQueue in Exercise 4.3.36). Again as with linked lists, it isbest to keep array-doubling code localto the implementation of fundamental datatypes and not worry about using it in client code.


Parameterized data types We have developed stackimplementationsthat allow us to build stacks of one particular type (Stri ng). But when developing client programs, weneedimplementations for collections of other types of data,notnecessarily String objects. A commercial transaction processing system mightneed to maintain collections of customers, accounts, merchants, and transactions;a university course scheduling system mightneedto maintaincollections of classes,students, and rooms; a portable music player might need to maintain collectionsof songs, artists, and albums; a scientific program might need to maintain collections of double or i nt values. In anyprogram that you write, you should not besurprised to find yourself maintaining collections for any type of data that youmightcreate. Howwouldyoudo so? After considering twosimple approaches (andtheir shortcomings) that usethe Java language constructswehavediscussed so far,we introduce a more advanced construct that can help us properly address thisproblem.

Create a newcollection data typeforeach item datatype. We couldcreate classesStackOfInts, StackOfCustomers, StackOfStudents, and so forth to supplementStackOfStri ngs. This approach requires that we duplicate the code for each typeof data, whichviolatesa basicpreceptof software engineeringthat we should reuse(not copy) codewhenever possible. You needa different class for every typeof datathat you want to put on a stack, so maintaining your codebecomes a nightmare:whenever youwantor needto make a change, youhave to do so in eachversion ofthe code.Still, this approachiswidely usedbecause many programminglanguages(including early versions of Java) do not provide anybetterway to solve the problem.Breaking this barrier is the signof a sophisticated programmer and programmingenvironment. Canweimplement stacks of Stri ng objects, stacks of integers,and stacksof data of any type whatsoever with just one class?

Use collections ofObjects. We could develop a stackwhose elements areallof typeObj ect. Using inheritance, wecanlegally push an objectof anytype (if wewant topush an object of type Appl e, we can do so becauseAppl e is a subclass of Object,as are all other classes). When we pop the stack,we must cast it back to the appropriate type (everything on the stackis an Object, but our code is processing objectsof type Appl e). In summary, if wecreatea class StackOfObjects by changingString to Object everywhere in one of our *StackOfSt rings implementations,we can write code like


StackOfObjects stack = new StackOfObjectsO;Apple a = new Apple();stack.push(a);

a = (Apple) (stack.popO);

thus achieving our goal of having a single class that creates and manipulates stacksof objects of any type. However, this approach is undesirable because it exposesclients to subtlebugs in clientprogramsthat cannot be detected until runtime. Forexample, there is nothing to stop a programmer from putting different types ofobjects on the samestack, as in the following example:

ObjectStack stack = new ObjectStack();Apple a = new Apple();Orange b = new OrangeO;stack.push(a);stack.push(b);a = (Apple) (stack.popO); // Throws a ClassCastException.b = (Orange) (stack.popO) ;

Using type casting in this way amounts to assuming that clients will cast objectspopped from the stack to the proper type, avoiding the protection provided byJava's typesystem. One reason that programmers use the typesystem is to protectagainst errors that arisefrom such implicit assumptions. The codecannot be type-checked at compile time: theremightbe an incorrect castthat occurs in a complexpiece of code that could escape detection until some particular runtime circumstance arises. We seek to avoid such errors because they can appear long after animplementation is delivered to a client, whowouldhave no wayto fixthem.

Java generics. Aspecific mechanism in Java known asgeneric types solves preciselytheproblem that wearefacing. Withgenerics, we canbuildcollections of objects ofa type to be specified by clientcode. Theprimarybenefit of doingso is to discovertype mismatch errors at compile time (whenthe software is being developed) insteadof at runtime (when the software isbeing used bya client, perhaps longafterdevelopment). Conceptually, generics are a bit confusingat first (their impact onthe programminglanguage is sufficiently deepthat theywere not included in earlyversions of Java), but our use of them in the present context involves just a smallbit of extra Java syntaxand is easyto understand. We name the generic class Stackand choose the generic name Item for the type of the objects in the stack (you

567


T^gfg^^

Bp*$?$"*:$

ti

%M

m

Program 4.3.4 Generic stack

public class Stack<Item>{

private Node first;

private class Node{

Item item;Node next;

}


public void push(Item item){ // Add item to top of stack.

Node oldfirst = first;first = new Node();first.item = item;first, next = oldfirst;

}

public Item pop(){ // Remove item from top of stack.

Item item = first.item;first = first, next;return item;

}


Stack<String> s = new Stack<String>();// See Program 4.3.1 for the test client.

}}

f i rst | first node on list

item

next

list item

next node on

^wm^^m^^^^^^<^^^s

This code is almost identical toProgram 4.3.2, butis worth repeating because it demonstrateshow easy it is to use generics toallow clients to make collections ofanytype of data. The keyword Item in this code isa type parameter, aplaceholderforan actual type name provided byclients.


can use any name). The code of Stack (Program 4.3.4) is identical to the code ofLinkedStackOfStrings (we drop the Linked modifier because we have a goodimplementation for clients who donot care about therepresentation), except thatwe replace everyoccurrence of Stri ngwith Item and declarethe classwith the following first line of code:

public class Stack<Item>

The name Itemisa type parameter, a symbolic placeholder for some actual type tobeused bytheclient. You canread Stack<Item> as stack ofitems, which ispreciselywhat we want. When implementing Stack,we donotknow theactual type of I tern,but a client canuse our stack forany type ofdata, including onedefined long afterwedevelop our implementation. Theclient code provides an actual typewhen thestack is created:

Stack<Apple> stack = new Stack<Apple>();Apple a = new Apple();

stack.push(a);

If you try to push an objectof the wrongtype on the stack, likethis:

Stack<Apple> stack = new Stack<Apple>();Apple a = new Apple();Orange b = new OrangeO;stack.push(a);stack.push(b); // Compile-time error.

you will get a compile-time error:

push(Apple) in Stack<Apple> cannot be applied to (Orange)

Furthermore, in our Stack implementation, Java canusethe type parameter Itemto check for typemismatch errors—even thoughno actual typeisyetknown,variables of type Item must be assigned values of type Item, and so forth.

Auto-boxing. Oneslight difficulty withgeneric code like Program 4.3.4 isthat thetype parameter stands for a reference type. How can we use the code for primitivetypes suchas i nt and double? TheJava language feature knownasauto-boxingandauto-unboxing enables us to reuse generic code with primitive types as well. Javasupplies built-in object typesknown aswrapper types, one for eachof the primitive


types: Boolean, Byte, Character, Double, Float, Integer, Long, and Short correspond to bool ean, byte char,doubl e,f1oat, i nt, 1ong, andshort, respectively.These classes consist primarily ofstatic methods suchasInteger. parselnt () andInteger.toBinaryStringO, and they also include non-static methods such ascompareToO and equals(). Java automatically converts between these referencetypes andthecorresponding primitive types—in assignments, methodarguments,and arithmetic/logic expressions—so that wecanwritecodelike the following:

Stack<Integer> stack = new Stack<Integer>();stack.push(17); // Auto-boxing (int -> Integer).int a = stack.pop(); // Auto-unboxing (Integer ~> int).

In this example, Java automatically casts (auto-boxes) the primitive value 17 tobe of type Integer when we pass it to the push() method. The pop() methodreturns an Integer, which Java casts (auto-unboxes) to an int before assigningit to the variable a. This feature is convenient for writing code, but involvesa significant amount of processing behind the scenes that can affect performance. Insome performance-critical applications, a class likeStackOfInts might be necessary,after all.

Genericsprovide the solution that weseek: they enable code reuse and at the sametime provide type safety. Studying Stack carefully and being sure that you understand each line of code will pay dividends in the future, as the ability to parameterize data types is an important high-level programming technique that iswell-supported in Java. You do not have to be an expert to take advantage of thispowerful feature.

Stack applications Pushdown stacks play an essential role in computation. Ifyou studyoperating systems, programming languages, and other advanced topicsin computer science, you willlearn that not only are stacksused explicitly in manyapplications, but they alsostillserve as the basisfor executingprograms written inhigh-level languages such as Java.

Arithmetic expressions. Someof the firstprograms that weconsideredin Chapter1 involved computing the valueof arithmetic expressions like this one:

(l+((2 + 3)*(4*5)))


If you multiply 4 by 5,add 3 to 2,multiply the result, and then add 1, you get thevalue 101. But how does the Java system do this calculation? Without going intothe details of how the Java system is built, we can address the essential ideas justbywritinga Java programthat can take a stringas input (the expression) and producethe number represented bythe expression asoutput. Forsimplicity, webeginwith the following explicit recursive definition: an arithmetic expression is either: anumber or a left parenthesis followed by an arithmetic expression followed by anoperator followed by another arithmetic expression followed by a right parenthesis. For simplicity, this definition is for fully parenthesized arithmetic expressions,which specifies preciselywhich operators apply to which operands—you are a bitmore familiar with expressionslike 1 + 2 * 3, in which we use precedence rulesinstead of parentheses. The same basic mechanisms that we consider can handleprecedence rules, but we avoid that complication. For specificity, we support thefamiliar binary operators *, +, -, and /, aswell as a square-rootoperator sqrt thattakesonly one argument. Wecould easily allow more operators and more kinds ofoperators to embrace a large class of familiar mathematical expressions, involvingtrigonometric, exponential, and logarithmic functions and whatever other operators we might wish to include. Our focus is on understanding how to interpret thestring of parentheses, operators, and numbers to enableperforming in the properorder the low-level arithmetic operations that are available on any computer.

Arithmetic expression evaluation. Precisely how can we convert an arithmeticexpression—a string of characters—to the value that it represents? A remarkablysimplealgorithm that wasdeveloped byEdsgarDijkstrain the 1960s usestwo pushdown stacks(one for operands and one for operators) to do this job.An expressionconsists of parentheses, operators, and operands (numbers). Proceeding from leftto right and taking these entities one at a time, we manipulate the stacks accordingto four possible cases, as follows:

• Push operands onto the operand stack.• Push operators onto the operator stack.• Ignore leftparentheses.• On encountering a rightparenthesis, pop an operator, pop the requisite

number of operands, and push onto the operand stack the result of applying that operator to those operands.

After the final right parenthesis has been processed, there is one value on the stack,which is the value of the expression. This method may seem mysterious at first, but


St.

*"S

M

i&^^L; £:£:I:1L^

Program 4.3.5 Expression evaluation

public class Evaluate{


Stack<String> ops = new Stack<String>();Stack<Double> vals = new Stack<Double>();while (!Stdln.isEmptyO){ // Read token, push if operator.

String s = Stdln.readString();if (s.equals("("))else if (s.equalsCV))else if (s.equalsC'-"))else if (s.equalsC*"))else if (s.equals(M/n))else if (s.equals("sqrt")) ops.push(s);else if (s.equalsC')")){ // Pop, evaluate, and push result

String op = ops.popO;double v = vals.popO;if (op.equals("+"))else if (op.equalsC-"))else if (op.equalsC'*"))else if (op.equalsC'/"))else if (op.equals("sqrt"))vals.push(v);

} // Token not operator or paren:

ops.push(s);ops.push(s);ops.push(s);ops.push(s);

}StdOut.pri ntln(vals.pop());

else vals.push(Double.parseDouble(s));

This Stack clientuses two stacks to evaluate arithmetic expressions, illustrating an essentialcomputational process: interpreting a string asaprogram and executing thatprogram tocompute the desired result. Executing a Java program is nothing other than a more complicatedversion of thissameprocess.

Java Evaluate(l+((2 + 3)*(4*5)))101.0

% Java Evaluate( ( 1 + sqrt ( 5.0 ) ) / 2.0 )1.618033988749895

,3^^Pi^ffl^iP«^^^W^^^^^wP^SSP'w^WI^PSt^HK^^^ ^^^^m^^^^^^^^^^^^^^^^^^^^^S^WWS^m^^^^'


it is easyto convince yourself that it computes the proper value: any time the algorithm encounters a subexpression consistingof two operands separated by an operator, all surrounded by parentheses, it leaves the result of performing that operation on those operands on the operand stack.The result is the same as if that valuehad appeared in the input instead of the subexpression, so we can think of replacing thesubexpression by the value to get an expressionthat would yield the same result. Wecan applythis argument again and again until we get asingle value. For example, the algorithm computes the same value of all of these expressions:

573

(l+((2 + 3)* (4* 5) ) )

( 1( 1( 1( 1101

( (( 5( 5100

+ 3 ) *(4*520 ) )

( 4) ) )

5 ) ) )

Evaluate (Program 4.3.5) is an implementation of this method. This code is a simpleexample of an interpreter: a program that interprets the computation specified by a givenstring and performs the computation to arrive at the result. A compiler is a program thatconverts the string into code on a lower-levelmachine that can do the job. This conversionis a more complicated process than the step-by-step conversion used by an interpreter, butit is based on the same underlying mechanism.Initially, Java was based on using an interpreter. Now, however, the Java system includes acompiler that converts arithmetic expressions(and, more generally, Java programs) into codefor the Java virtualmachine, an imaginary machine that is easy to simulate on an actual computer.

+ C (2 + 3) * (4* 5) ) )

I ( (2 +3) * (4* 5) ) )

+ 3) 5) ) )

(4*5)))

5) ) )

(4*5)))

(4*5)))

5) ) )

5) ) )

) ) )

k.%^

))

Trace of expression evaluation (Program 4.3.5)


Stack-based programming languages. Remarkably, Dijkstra's 2-stack algorithmalso computes the same value as in our example for this expression:

(l((23 + )(45*)*)+)

In other words, we can put each operator after its two operands instead of betweenthem. In such an expression, each right parenthesis immediately follows an operator so we can ignore both kinds of parentheses, writing the expressions as:

123 + 45** +

This notation is known as reverse Polish notation, or postfix. Toevaluate a postfix expression, we use one stack (see Exercise 4.3.15). Proceeding from left to right, taking these entities one at a time, we manipulate the stacksaccording to just two possible cases,as follows:

• Push operands onto the operand stack.• On encountering an operator, pop the requisite

number of operands and push onto the operandstack the result of applying the operator to thoseoperands.

$TT

£ 5 20

1 2

2 3

3 +

+ 4

4 5

5 *Again, this process leaves one value on the stack, whichis the value of the expression. This representation is sosimple that some programming languages, such as Forth(a scientific programming language) and PostScript (apage description language that is used on most printers)use explicitstacks.For example,the string 1 2 3 + 45** + is a legalprogram in both Forth and PostScript thatleaves the value 101 on the execution stack. Aficionados

of these and similar stack-based programming languages prefer them because theyare simpler for many types of computation. Indeed, the Javavirtual machine itselfis stack-based.

3 + 45

+ 45*

4 5 * *

Trace ofpostfixevaluation

Function-call abstraction. Mostprogramsuse stacksimplicitlybecausethey support a natural way to implement function calls,as follows: at any point during theexecution of a method, define its state to be the values of all of its variables and apointer to the next instruction to be executed. One of the fundamental characteristics of computing environments is that everycomputation is fullydetermined byits state (and the value of its inputs). In particular, the system can suspend a com-


public static void sort(a,{

int N = 4 - 0;if (N <= 1) return;sort(a, 0, 2); -<sort(a, 2, 4);// merge

}

0, 4)

public static void sort(a, 0, 4) jpublic static void sort(a, 0, 2){

int N = 2 - 0;if (N <= 1) return;sort(a, 0, 1); -<sortCa, 1, 2);// merge

}

public static void sort(a, 0, 4) I/ i—— • — •—

public static void sort(a, 0, 2) |public static void sort(a,{

int N a 1 - 0;if (N <= 1) return; -<-sort(a, 0, 1);sort(a, 1, 2);// merge

}

0, 1)

public static void sort(a, 0, 4)]public static void sort(a, 0, 2){

int N m 2 - 0;if (N <= 1) return;sort(a, 0, 1);

sort(a, 1, 2); -<// merge

}

public static void sort(a, 0, 4) |public static void sort(a, 0, 2) |

public static void sort(a, 1, 2){

int N = 2 - 1;if (N <= 1) return; -<sort(a, 0, 1);sort(a, 1, 2);// merge

}

public static void sort(a, 0, 4) |public static void sort(a, 0,{

int N - 2 - 0;if (N <= 1) return;sort(a, 0, 2);sort(a, 2, 4);// merge

} // return •<

public static void sort(a, 0,{

int N o 4 - 0;if (N <o l) return;sort(a, 0, 2);sort(a, 2,4); -<// merge

}

4)

•push

-push

•pop

•push

•pop

•pop

• push

Usinga stack to supportfunction calls

putation by saving awayits state, then restart itby restoring the state. If you take a course aboutoperating systems, you will learn the details ofthis process, because it is critical to much of thebehavior of computers that we take for granted(for example, switching from one applicationto another is simply a matter of saving and restoring state). Now, the natural way to implement the function-call abstraction, which is

used by virtually all modern programming environments, is to use a stack. To call a function,push the state on a stack. To return from a function call,pop the state from the stack to restoreall variables to their values before the function

call, substitute the function return value (ifthere is one) in the expression containing thefunction call (if there is one), and resume execution at the next instruction to be executed

(whose location was saved as part of the stateof the computation). This mechanism workswhenever functions call one another, even re

cursively. Indeed, if you think about the processcarefully, you will see that it is essentially thesame process that we just examined in detail forexpression evaluation. A program is a sophisticated expression.The pushdown stack is a fundamental computational abstraction. Stacks have been used for

expression evaluation, implementing the function-call abstraction, and other basic tasks since

the earliestdaysof computing. Wewill examineanother (tree traversal) in Section 4.4. Stacksare used explicitly and extensively in many areas of computer science, including algorithmdesign, operating systems, compilers, and numerous other computational applications.

575


enqueue

m

enqueue

CD

dequeue

CD

dequeue

CD

Iqueueof customers

"imaCD CD CD

TCDQ

TCDQ

first in lineleaves queue

new arrivalat the end

CE) CD CD CD

new arrivalat the end

\CD CD CD CD CD

\ enCD |CDCDCDCD

next in lineleaves queue

FIFO queues A FIFO queue (orjust a queue) is a collection that isbased on the first-in-first-out (FIFO)policy.

The policy of doing tasks in thesame order that they arrive is one thatwe encounter frequently in everydaylife, from people waiting in line at atheater, to cars waiting in line at a tollbooth, to tasks waiting to be servicedby an application on your computer.

One bedrock principle of anyservice policy is the perception offairness. The first idea that comes to

mind when most people think aboutfairness is that whomever has been

waiting the longest should be servedfirst. That is precisely the FIFO discipline, so queues play a central role innumerous applications. Queues area natural model for so many everyday phenomena, and their propertieswere studied in detail even before the

advent of computers.As usual, we begin by articulating

queue insert operation enqueue and thethe followingAPI:

an API

remove

CD TCDCD(ZD

A typical FIFO queue

, Again by tradition, we name theoperation dequeue, as indicated in

public class Queue<Item>

Queue<ltem>0

boolean isEmptyO

void enqueue(Item item)

Item dequeueO

int 1engthO

APIfor a generic FIFO queue

create an empty queue

is thequeueempty?

enqueue an item

dequeuean item

queuelength


Asspecified in this API,we will use generics in our implementations, so that we canwrite client programs that safely build and use queues of any reference type. Weinclude a 1ength () method, even though we did not havesuch a method for stacksbecause queue clients often do need to be aware of the number of items in thequeue, whereas most stack clients do not (see Program 4.3.8 and Exercise 4.3.9).

Applying our knowledge from stacks,we can use linked lists or array doublingto develop implementations where the operations take constant time and thememory associated with the queue grows and shrinks with the number of elementsin the queue. As with stacks, each of these implementations represents a classicprogramming exercise. Youmay wish to think about how you might achieve thesegoals in an implementation before reading further.

Linked-list implementation. To implement a queue with a linked list, we keepthe items in order of their arrival (the reverse of the order that we used in Stack).The implementation of dequeue() is the same as the popO implementation inStack (save the item in the first list

save a link to the last node

Node oldlast = last;

oldlast

f i rst

create a new nodefor theend

Node last = new NodeO;last.item = "not";

577

node, remove the first list node from

the queue, and return the saved item).Implementing enqueue(), however,is a bit more challenging: how do weadd a node to the end of a linked list?

To do so, we need a link to the last

node in the list, because that node's

link has to be changed to reference anew node containing the item to beinserted. In Stack, the only instancevariable is a reference to the firstnodein the list; with only that information,our only recourse is to traverse allthe nodes in the list to get to the end.That solution is unattractive when

lists might be lengthy. A reasonablealternative is to maintain a second in

stance variable that always referencesthe lastnode in the list. Adding an extra instance variable that needs to be

f i rst *I1

not

null

linkthenew nodeto theend of the list

oldlast.next = last;

oldlast

fi rst -

last

Inserting a newnodeat theend of a linked list


Program 4.3.6 GenericFIFOqueue (linked list)

public class Queue<Item>{

private Node first;private Node last;

private class Node

{Item item;Node next;

}


public void enqueue(Item item){ // Add item to the end of the list.

Node oldlast = last;last = new Node();last.item = item;last.next = null;

if (isEmptyO) first = last;else oldlast.next = last;

}

public Item dequeueO{ // Remove item from the beginning of the list.

Item item = first.item;first = first,next;if (isEmptyO) last = null;return item;

}

public static void main(String[] args){ // Test client is similar to Program 4.3.2.

Queue<String> q = new Queue<String>();}

f i rst

last

item

next

firstnodeon list

last node on list

list item

next node on list

•wm-im^m&m^m& «HSBtt9»

This implementation is very similar to our linked-list stack implementation (Program 4.3.2):dequeueO isalmost the same aspop() , fct/fenqueueO links the newitem onto the endofthelist, notthe beginning as in push(). To doso, it maintains an instance variable thatreferencesthelastnode on thelist. The 1ength () method is leftfor an exercise (seeExercise 4.3.11).

% Java Queue < tobe.txtto be or not to be

^W^^^^^SW^^^^^^^^^^^^^^'


Stdln StdOut

to

be

or

not

to

to

be

be

or

that

not

to

be

is

Trace ofQueue test client (see Program 4.3.6)

579


maintained is not something that should be taken lightly, particularly in linked-listcode, because every method that modifies the list needs code to check whetherthat variableneeds to be modified (and to make the necessarymodifications).Forexample, removing the first node in the list might involve changing the referenceto the last node in the list, since when there is only one node in the list, it is boththe first one and the last one! (Details like this make linked-list code notoriouslydifficult to debug.) Queue (Program 4.3.6) is a linked-list implementation of ourFIFOqueue interface that has the sameperformance properties as Stack: all of themethods are constant-time,and space usage is proportional to the queue size.

Array implementations. It is also possible to develop FIFO queue implementations that use arrays having the same performance characteristics as those that wedeveloped for stacks in ArrayStackOfSt rings (Program 4.3.1) and Doubli ngStackOfStri ngs (Program 4.3.3). These implementations are worthy programming exercises that you are encouraged to pursue further (see Exercise 4.3.18).

Random queues. Even though they are widely applicable, there isnothing sacredabout FIFO and LIFO. It makes perfect sense to consider other rules for removing items. One of the most important to consider is a data type where dequeueOremoves a random element (samplingwithout replacement), and we have a method sampl e() that returns a random elementwithout removing it from the queue(sampling with replacement). Such actions areprecisely called for in numerous applications, some of whichwe have already considered, starting with Sample (Program 1.4.1). With an array representation, implementing sampl e() is straightforward,and we can use the sameidea as in Program 1.4.1 to implement dequeueO(exchange a random elementwith the lastelementbeforeremoving it). We use thename RandomQueue to refer to this data type (see Exercise 4.3.36). Note that thissolution depends on using an array representation; getting to a random elementfrom a linked list in constant time is not possible becausewe haveto start from thebeginning and traverse links to find it.With a (doubling) array representation, allof the operations are implemented in constant (amortized) time.

Thequeue, randomqueue, and stackAPIs are essentially identical—they differonlyin the choice of class and methodnames (which are chosen arbitrarily). Thinkingabout this situation is a goodwayto cementunderstandingof the basicissues surroundingdata typesthat weintroducedin Section3.3. The true differences among


these data types are in the semantics of the remove operation—which item is to beremoved? The differences between stacks and queues are in the English-languagedescriptions of what they do. These differences are akin to the differences betweenMath .sin (x) and Math.1og(y), but we might want to articulate them with a formal description of stacks and queues (in the same way as we have mathematicaldescriptions of the sine and logarithm functions).But precisely describingwhat wemean by first-in-first-out or last-in-first-out or random-out is not so simple. Forstarters, what languagewould you use for such a description? English? Java? Mathematical logic? The problem of describinghow a program behavesis known as thespecification problem, and it leads immediatelyto deep issues in computer science.One reason for our emphasis on clear and concise code is that the code itself canserve as the specification for simple data types such as stacks and queues.

Queue applications In the past century, FIFO queues proved to be accurateand useful models in a broad variety of applications, ranging from manufacturing processes to telephone networks to trafficsimulations. A field of mathematicsknown as queuing theory has been used with great success to help understand andcontrol complex systems of all kinds. FIFO queues also play an important role incomputing. You often encounter queues when you use your computer: a queuemight hold songs on a playlist,documents to be printed, or events in a game.

Perhaps the ultimate queue applicationis the internet itself, which is based onhuge numbers of messages moving through huge numbers of queues that have allsorts of different properties and are interconnected in allsorts of complicated ways.Understanding and controlling such a complexsysteminvolves solid implementations of the queue abstraction, application of mathematical results of queueingtheory, and simulation studies involving both. Weconsider next a classic exampleto give a flavor of this process.

MIDII queue. One of the simplestqueueingmodelsisknown asan M/D/l queue.The M indicates that arrivals obey a Markov process (in this context, a Poisson process where arrivals obey a specific probability distribution that has been shown toaccuratelymodel many real-world situations), the D indicates that departures aredeterministic (happen at a fixedrate), and the 1 indicates that there is one server.Itisan appropriate model for a situation likea single line of carsentering a toll booth:they arrive at randomly spaced intervals, but leave at fixed intervals. An M/D/lqueue is parameterized by its arrival rate k (for example, the number of cars per


minute arriving at the toll booth) and its departure rate |jl (forexample,the number of carsper minute that can pass throughthe toll booth) and is characterized by three properties:

• There is one server (a FIFO queue).• Arrivals are described by a Poisson process with rate X,

where the arrivals come from an exponential distribution(see Exercise 2.2.14).

• Departures happen at a fixedrate of |jlwhen the queue isnonempty.

Note that the queue will grow without bound unless |x > X.Otherwise, customers enter and leavethe queue in an interesting dynamic process. Also note that the time between arrivalsis l/X minutes, on the average, and the time between departures, when the queue is nonempty, is 1/|ul minutes.

Analysis. In practical applications, people are interested inthe effectof the valuesof the parameters on various propertiesof the queue. If you are a customer,you maywant to know theexpected amount of time you will have to wait in the queue;if you are designingthe system, you might want to know howmany customers are likely to be in the queue, or somethingmore complicated, such as the likelihood that the queue sizewill exceeda given maximum size. For simple models, probability theory yields formulas expressing these quantities asfunctions of Xand (x. For M/D/l queues, it is known that:

• The average number of customers in the systemL is\2/(2|x(Ijl-X)) + \/|x.

• The averagewait time Wis XI (2 |jl (fi - X)) + l/|x.

For example, if the carsarriveat an average rate of 10per minute and the servicerate is 15per minute, then the average number of cars in the systemwill be 4/3 and the average wait timewill be 2/15 minutes or 8 seconds. These formulas confirm

that the wait time (and queue length) grow without bound asXapproaches \l. They also obeya general rule known as Little'slaw: the average number of customersin the systemis Xtimesthe average wait time (L = XW) for many types of queues.

Ted

Tam

qd Ten

Tedcd

CD IED

time (seconds)

ED T

TcocbTcdcdcd

cdTcdcd

qdTcd

i- 0

-10

-20

30

CO

CO

CO

CO

COCO

arrival departure wait

0

2

7

17

19

21

5

10

15

23

28

30

An M/D/l queue


pmi

h^^M^Ml^S^^^^^^h.

Program 43J M/D/l queue simulation

public class MDlQueue{


double lambda = Double.parseDouble(args[0]);double mu = Double.parseDouble(args[1]);Histogram hist = new Histogram(60 + 1);Queue<Double> queue = new Queue<Double>();double nextArrival = StdRandom.exp(lambda);double nextService = nextArrival + 1/mu;while (true)

{while (nextArrival < nextService){ // Simulate an arrival.

queue.enqueue(nextArrival);nextArrival += StdRandom.exp(lambda);

} // Arrivals done; simulate a service.double wait = nextService - queue.dequeueO;StdDraw.clearO;hist.addDataPoi nt(Math.mi n(60,hist.drawO;StdDraw.show(20);if (queue.isEmptyO)

nextService = nextArrival +

else

nextService = nextService +

•g

lambda arrival rate

mu service rate

hist histogram

queue M/D/l queue

wait time on queue

(int) (wait)));

}

1/mu;

1/mu;

This simulation of an M/D/l queue keeps track of time with two variables nextArrival andnextService and a single Queue of double values to calculate wait times. Thevalue of eachitem on the queue is the (simulated) time it entered thequeue. Thewaiting timesareplottedusingHi stogram (Program 3.2.3).

Wa •:•'


Simulation. MDlQueue (Program 4.3.7) is a Queue client that you can use to validate these sorts of mathematical results. It is a simple example of an event-basedsimulation: we generate events that take place at particular times and adjust ourdata structures accordingly for the events, simulating what happens at the timethey occur. In an M/D/l queue, there are two kinds of events: we either have a customer arrival or a customer service, so we maintain two variables:

• nextServi ce is the time of the next service.

• nextArrival is the time of the next arrival.

Tosimulate an arrival event,weenqueue a doubl e value (nextArri val, the time ofarrival); to simulatea service,wedequeue avalue,compute the wait time (nextSe r-vi ce, which is the time of service,minus the value that came off the queue, which isthe time of arrival) and add the wait time data point to the histogram (seeProgram3.2.3). The shape that results after a large number of trials is characteristic of theM/D/l queueing system.From a practical point of view,one ofthe most importantcharacteristics of the process,which you can discover for yourself by running MDlQueue for various values of Xand |ul, is that averagewait time (and queue length)can increase dramatically when the service rate approaches the arrival rate. Whenthe service rate is high, the histogram has a visible tail where the frequency of customers having a given wait time decreases to being negligible as the wait time increases.But when the service rate is closeto the arrival rate, the tail of the histogramstretches to the point that most values are in the tail, so the frequency of customershaving at least the highest wait time displayeddominates.

As in many other applications that we have studied, the use ofsimulation to validate

a well-understood mathematical model is a starting point for studying more complex situations. In practical applications of queues, we may have multiple queues,multiple servers, multi-stage servers,limits on queue size,and many other restrictions. Moreover, the distributions of arrival and service times may not be possibleto characterize mathematically.In such situations, we may have no recourse but touse simulations. It is quite common for a system designer to build a computationalmodel of a queuing system (such as MDlQueue) and to use it to adjust design parameters (such as the service rate) to properly respond to the outside environment(such as the arrival rate).


Iterable collections As mentioned earlier in this section, one of the fundamental operations on arrays and linked lists is the for loop idiom that we use to processeach entry. This common programming paradigm need not be limited to low-leveldata structures such as arrays and linked lists. For any collection, the ability toprocess all of its items (perhaps in some specified order) is a valuable capability.The client's requirement is just to process each of the items in some way, or to iterate through the items in the collection. This paradigm is so important that it hasachieved first-classstatus in Javaand many other modern languages (the programming language itself has specific mechanisms to support it, not just the libraries).With it, we can write clear and compact code that is free from dependence on thedetails of a collection's implementation.

To introduce the concept, we start with a snippet of client code that prints allof the items in a collection of strings, one per line:

Stack<String> collection = new Stack<String>();

for (String s : collection)StdOut.println(s);

This construct is known as the foreach statement: you can read the for statementasfor each strings in thecollection, prints. This client code does not need to knowanything about the representation or the implementation of the collection; it justwants to process each of the items in the collection. The same for loop would workwith a Queue of strings or any other iterable collection.

We could hardly imagine code that is more clear and compact. However, implementing a collection that supports it requires some extra work, which we nowconsider in detail. First, the foreach construct is shorthand for a while construct

(just like the for statement itself). For example, the foreach statement above is exactly equivalent to the following whi1e construct:

Iterator<String> i = collection.iterator();whi1e (i.hasNext()){

String s = i.next();StdOut.println(s);

}


This code exposes the threejiecessary elements thatwe need to implement in anyiterable collection:

• The collection must implement an i terator () method that returns anIterator object.

• The Iterator class must include two methods: hasNextO (which returnsa bool ean value) and next () (which returns an item from the collection).

In Java, we use the interface mechanism to express the idea that a class implements a specific method (see Section 3.3). For iterable collections, the necessaryinterfaces are already defined for us in Java.

To make a class iterable, the first step is to add the phrase implementsIterabl e<Item> to its declaration, matching the interface

public interface Iterable<Item>{

Iterator<Item> iterator();

}

(which is in java. 1ang. Iterabl e), and to add a method to the class that returnsan Iterator<Item>. Iterators are generic;we can either use them in a generic classor just use them to provide clients with the ability to iterate through a specific typeof objects.

What is an iterator? An object from a classthat implements the methods has-Next() and next(), as defined in the following interface (which is in Java.uti 1.Iterator):

public interface Iterator<Item>{

boolean hasNextO;Item next();

void remove();

}

Although the interface requires a remove () method, we always use an empty method for remove () in this book, because interleaving iteration with operations thatmodify the data structure is best avoided.

Asillustrated in the followingtwo examples,implementing an iterator classisoften straightforward for array and linked-list representations of collections.


Implementing an iterator for a class that uses an internal array. As a first example, we will consider all of the steps needed to make ArrayStackOfSt rings(Program 4.3.1) iterable. First, change the class declaration to:

public class ArrayStackOfStrings implements Iterable<String>

In other words, we are promising to provide an i te rato r () method so that a clientcan use a foreach statement to iterate through the strings in the stack.The i tera-tor() method itself is simple:

public Iterator<String> iterator()

{ return new ArraylteratorO; }

It just returns an object from a private nested class that implements the Iteratorinterface (which provides hasNextO, next(), and remove() methods):

private class Arraylterator implements Iterator<String>{

private int i = N-l;

public boolean hasNextO{ return i >= 0; }

public Item next(){ return a[i—]; }

public void remove(){ }

}

Note that the nested classcan access the instancevariables of the enclosingclass, inthis case a[] and N(this ability is the main reason we use nested classesfor iterators). One crucial detail remains: we have to include

import Java.util.Iterator;

at the beginning of the program because (for historical reasons) Iterator is notpart of the standard library (eventhough Iterabl e ispart of the standard library).Now a client using the foreach statement for this class will get behavior equivalentto the common for loop for arrays,but does not need to be awareof the array representation (an implementation detail). This arrangement is of critical importancefor implementations offundamental data types likethose included in Javalibraries.For example, it freesus to switch to a totallydifferent representation without havingtochange anyclient code. More important, taking the client's point of view,it allows


clients to use iteration withouthaving to know any details of the class implementation.

Implementing an iterator for a class that uses a linked list. The same specificsteps (with different code) are effective to make Queue (Program 4.3.6) iterable,even though it is generic. First,we change the classdeclaration to:

public class Queue<Item> implements Iterable<Item>

In other words,we are promising to provide an i te rato r () method so that a clientcan use a foreach statement to iterate through the items in the stack,whatever theirtype.Again, the i terator () method itselfis simple:

public Iterator<Item> iterator()

{ return new ListlteratorO; }

Asbefore,we have a private nested class that implements the Iterator interface:

private class Listlterator implements Iterator<Item>{

Node current = first;

public boolean hasNextO{ return current != null; }

public Item next()

{Item item = current.item;current = current.next;

return item;

}


}

Again,a client can build a queue of objectsof any type and then iterate through theobjects without any awareness of the linked-list representation:

Queue<String> queue = new Queue<String>();

for (String s : queue)

StdOut.println(s);


This client code is a clearer expression of the computation and therefore easier to write and maintain than

code based on the low-level representation.

Our stack iterator goes throughthe items in LIFO order and our

queue iterator goes through them inFIFO order, even though there is norequirement to do so: we could return the itemslnany order whatsoever. However, when developing iterators, it is wise to follow a simple rule:if a data type specification implies anatural iteration order, use it.

Ite rato r implementationsmayseem a bit complicated to you at first,but they are worth the effort. Youwillnot find yourself implementing themvery often, but when you do, you willenjoy the benefits of clear and correctclient code and code reuse. Moreover,as with any programming construct,once you begin to enjoy these benefits, you will find yourself taking advantage of them often.

Makinga class iterable certainlychanges its API, but to avoid overlycomplicated API tables, we simplyuse the adjective iterable to indicatethat we have included the appropriate code to a class, as described in this

section, and to indicate that you canuse the foreach statement in client code

ent programs the iterable (and generic)described here.

589

[import Java.util .Iterator;


{

Iteratornot in language

implements Iterable<Item>

private Node first;private Node last;private class Node

{Item item;Node next;

}public void enqueue(Item item)

public Item dequeue()

public Iterator<Item> iteratorO{ return new ListlteratorQ; }

promise to- implementiteratorO

FIFO

queuecode

implementationfor Iterable

interface

additionalcode to

make theclass iterable

Iprivate class Listlterator

Iimplements Iterator<Item>

}

Node current = first;

public boolean hasNextO{ return current != null; }

public Item next(){

Item item = current.item;current = current.next;

return item;

}


Kpromise to implementhasNextO, next(),

and remove ()

implementationsfor Iterator

interface


Queue<Integer> queue = new Queue<Integer>();while (! Stdln. isEmptyO)

queue.enqueue(StdIn.readlntO) ;for (int s : queue)

}StdOut.println(s);

foreachstatement

Anatomy of an iterable class

From this point forward we will use in cli-Stack, Queue,and RandomQueue data types


Resource allocation Next, we examine an application that illustrates the language features that we have been considering. A resource-sharing system involvesa large number of loosely cooperating servers who want to share resources. Eachserver agrees to maintain a queue of items for sharing, and a central authoritydistributes the items to the servers (and informs users where they may be found).For example, the items might be songs, photos, or videos to be shared by a largenumber of users. To fix ideas, we will think in terms of millions of items and thousands of servers.

We will consider the kind of program that the central authority might useto distribute the items, ignoring the dynamics of deleting items from the systems,adding and deleting servers,and so forth.

If we use a round-robin policy, cycling through the servers to make the assignments, we get a balanced allocation,but it is rarelypossible for a distributor to havesuch complete control over the situation: for example, there might be a large number of independent distributors, so none of them could have up-to-date information about the servers. Accordingly, such systems often use a random policy, wherethe assignments are based on random choice. An even better policy is to choose arandom sample of servers and assign a new item to the one that has smallestnumber of items. For small queues, differences among these policies is immaterial, butin a system with millions of items on thousands of servers, the differences can bequite significant, since each serverhas a fixedamount of resources to devote to thisprocess. Indeed, similar systems are used in internet hardware, where some queuesmight be implemented in special-purposehardware, so queue length translates directlyto extra equipment cost.But how big a sample should we take?

LoadBal ance (Program 4.3.8) is a simulation of the sampling policy,whichwe can use to study this question. This program makes good use of the high-levelconstructs (generics and iterators) that wehavebeen considering to provide an easily understood program that we can use for experimentation. We maintain a random queue of queues of strings and build the computation around an inner loopwhere we put each new request on the smallest of a sample of queues, using thesample() method from RandomQueue to randomly sample queues. The surprisingend result is that samples of size two lead to near-perfect balancing, so there is nopoint in taking larger samples.


U

HI

wm

Program 43.8 Load balancing simulation

public class LoadBalance{

public static void main(String[] args){ // Assign N items to M servers, using

// shortest-in-a-sample (of size S) policy,int M = Integer.parselnt(args[0]);int N = Integer.parselnt(args[l]);int S = Integer.parselnt(args[2]);

// Create server queues.RandomQueue<Queue<Integer» servers;servers = new RandomQueue<Queue<Integer»();for (int i = 0; i < M; i++)

servers.enqueue(new Queue<Integer>());

for (int j = 0; j < N; j++){ // Assign an item to a server.

Queue<Integer> min = servers.sample();for (int k = 1; k < S; k++){ // Pick a random server, update if new min

Queue<Integer> q = servers.sample();if (q.lengthO < min.lengthO) min = q;

} // min is the shortest server queue.min.enqueue(j);

}

int i = 0;doubled lengths = new double[M];for (Queue<Integer> q: servers)

lengths[i++] = q.lengthO;StdDraw.setYscale(0, 2.0*N/M);StdStats.piotBars(1engths);

M

N

S

servers

max

numberof servers

numberof items

samplesize

queues

shortestin sample

current value

y^^^^^^^w^^^^w.

This generic Queue client simulates the process ofassigning N items to a setofM servers. Requests areput on theshortest of a sample ofS queues chosen at random.


We haveconsidered in detail the issuessurrounding the space and time usageof basic implementations of the stack and queue APIs not just because these data typesare important and useful,but alsobecauseyou are likelyto encounter the very sameissues in the context of your own data type implementations.

Should you use a pushdown stack, a FIFO queue, or a random queue whendeveloping a client that maintains collections of data? The answer to this question depends on a high-levelanalysis of the client to determine which of the LIFO,FIFO, or random disciplines is appropriate.

Should you use an array, a linked list, or a doubling array to structure yourdata? The answer to this question depends on low-level analysis of performancecharacteristics.With an array, the advantage is that you can access any element inconstant time and the disadvantage that you need to know the maximum size inadvance. A linked listhas the advantage that you do not need to know the maximum size in advance and the disadvantage that you cannot access an arbitraryelement in constant time. A doubling array combines the advantages of arrays andlinked lists (you can accessany element in constant time but do not need to knowthe maximum size in advance) but has the (slight) disadvantage that the constantrunning time is on an amortized basis.Each is appropriate in various different situations; you are likely to encounter all three in most programming environments.For example, the Javaclass java.util .ArrayList uses a doubling array, and theJava class Java. uti 1. Li nkedLi st uses a linked list.

The powerful high-level constructs and new language features that we haveconsidered in this section (generics and iterators) are not to be taken for granted.They are sophisticated language features that did not come into widespread use inmainstream languages until the turn of the century, and they still are used mostlyby professional programmers. But their use is skyrocketing because they are well-supported in Javaand C++, because new languages such as Python and Ruby embrace them, and because many people are learning to appreciate the value of usingthem in client code. Bynow,you know that learning to use a new language featureis not so different from learning to ride a bicycle or implement Hell0W0rid: itseems completely mysterious until you have done it for the first time, but quicklybecomes second nature. Learning to use generics and iterators will be well worthyour time.


Q. When do I use newwith Node?

A. Just aswithanyotherclass, youshould only use new when youwantto create anew Node object (a new element in the linked list).Youshould not use new to createa new reference to an existingNode object.For example, the code

Node oldfirst = new Node();oldfirst = first;

creates a new Node object, then immediately loses track of the only reference to it.Thiscodedoesnot resultin an error, but it is a bit untidyto create orphans for noreason.

Q. Whydeclare Node asa nested class? Why pri vate?

A. Bydeclaring the nested class Node to be pri vate, we restrict access to methodswithin the enclosing class. Noteforexperts: Anestedclass that isnot static isknownas an inner class, so technically our Node classes are inner classes, though the onesthat are not generic could be static.

Q. When I type javac Li nkedStackOfStrings. Java to run Program 4.3.2 andsimilar programs, I find a file LinkedStackOfSt ri ngs$Node.cl ass in addition toLinkedStackOfSt ri ngs. cl ass. What is the purpose of that file?

A. That file is for the nested class Node. Java's naming convention is to use $ toseparate the name of the outer class from the nested class.

Q. Should a client be allowed to insert null items ontoa stack or queue?

A. This question arises frequently when implementing collections in Java. Ourimplementation (and Java's stackand queue libraries) do permit the insertion ofnull values.

Q. Arethere Java librariesfor stacks and queues?

593


A. Yes and no. Java has a built-in library called j ava. uti 1. Stack, but you shouldavoid using it when you want a stack. It has several additional operations that arenot normally associated with a stack, e.g., getting the ith element. It also allowsadding an element to the bottom of the stack (instead of the top), so it can implement a queue! Although havingsuch extra operations may appear to be a bonus, itis actually a curse.Weusedata typesnot because they provide everyavailable operation, but rather becausethey allow us to precisely specify the operations we need.The prime benefit of doing so is that the systemcan prevent us from performingoperations that we do not actually want.The j ava. uti 1. Stack API is an exampleof a wide interface, which we generally striveto avoid.

Q. I want to use an array representation for a generic stack, but code like the followingwill not compile.What is the problem?

private Item[] a = new Item[max];

A. Good try. Unfortunately, creatingarrays of generics is not allowed in Java 1.5.Experts stillarevigorously debating thisdecision. As usual, complaining too loudlyabout a language feature puts you on the slippery slope toward becoming a languagedesigner.There is a wayout, using a cast.Youcan write:

private Item[] a = (Item[]) new Object[max];

Q. Can I use a foreach loop with arrays?

A, Yes (even though arrays do not implementthe Iterator interface). The following one-liner prints out the command-line arguments:


{ for (String s : args) StdOut.println(s); }

Q. Why not have a singleCol 1ecti on data type that implements methods to additems, remove the most recently inserted, remove the least recently inserted, remove random, iterate, return the number of items in the collection, and whateverother operations we might desire? Then we could get them all implemented in asingle class that could be used by many clients.


A, This is an example of a wide interface, which, aswe pointedout in Section3.3,are to be avoided. One reason to avoid wide interfaces is that it is difficult to con

struct implementations that are efficient for alloperations. A more important reason is that narrow interfaces enforce a certaindiscipline on your programs,whichmakes client code much easier to understand. If one client uses Stack<String>and another usesQueue<Customer>, wehave a good ideathat the LIFO disciplineis important to the firstand the FIFO discipline is important to the second.Another approach is to use inheritanceto try to encapsulate operationsthat are commonto allcollections. However, such implementations arefor experts, whereas anyprogrammer can learn to build generic implementations such as Stack and Queue.

595


ExercismM

4.3.1 AddamethodisFullO to ArrayStackOfStrings (Program4.3.1)

4.3.2 Give the output printed by j ava ArrayStackOfSt rings 5 for the input:

it was - the best - of times - - - it was - the - -

4.3.3 Supposethat a clientperformsan intermixedsequenceof (stack) push andpop operations. The push operations put the integers 0 through 9 in order on tothe stack; the pop operations print out the return value. Which of the followingsequence(s) could notoccur?

a. 4321098765

b. 4687532901

c 2567489310

d. 4321056789

e. 1234569870

/ 0465381729g. 1479865302

h. 2143658790

4.3.4 Write a stack client Reverse that reads in strings from standard input andprints them in reverse order.

4.3.5 Assume that standard input has some unknown number N of doubl e values. Write a method that reads all the values and returns an array of length N containing them, in the order they appear on standard input.

4.3.6 Write a stack client Parentheses that reads in a text stream from standard

input and uses a stack to determine whether its parentheses are properly balanced.For example, your program should print true for [()]{}{[()()]()} and fal sefor [ (]). Hint: Use a stack.

4.3.7 What does the following code fragment print when Nis 50? Give a high-level description of what the code fragment in the previous exercise does whenpresented with a positive integer N.


Stack<Integer> stack = new Stack<Integer>();while (N > 0){

stack.push(N % 2);N = N / 2;

}while (! stack. isEmptyO)

StdOut.print(stack.popO);StdOut.printlnO;

Answer: Prints the binary representation of N(110010when Nis 50).

4.3.8 Whatdoesthe following code fragment do to the queueq?

Stack<String> stack = new Stack<String>();while (Iq.isEmptyO)

stack.push(q.dequeueO);while (!stack.isEmptyO)

q. enqueue(stack. popO) ;

4.3.9 Add a method peek() to Stack (Program 4.3.4) that returns the most recently inserted element on the stack (without popping it).

4.3.10 Give the contents andsize of thearrayforDoubl i ngStackOfSt ri ngs withthe input:

it was - the best - of times - - - it was - the - -

4.3.11 Add a method length() to Queue (Program4.3.6) that returns the number of elements on the queue. Hint: Make sure that your method takes constanttime by maintaining an instance variable Nthat you initialize to 0, increment inenqueue(), decrement in dequeue(), and return in length().

4.3.12 Drawa memory usage diagram in the style of the diagrams in Section4.1for the three-node example used to introduce linked lists in this section.

597


4.3.13 Write a programthat takes fromstandardinput an expression without leftparentheses and prints the equivalent infix expression with the parentheses inserted. For example, giventhe input:

l + 2)*3-4)*5-6)))

your program should print

( ( 1 + 2 ) * ( ( 3 4 ) * ( 5 - 6 ) )

4.3.14 Write a filter Infi xToPostfi x that converts an arithmetic expression frominfix to prefix.

4.3.15 Write a program EvaluatePostfix that takes a postfix expression fromstandard input, evaluates it, and prints the value. (Piping the output of your program from theprevious exercise tothisprogram gives equivalent behavior to Eva! -uate, in Program 4.3.5).

4.3.16 Suppose that a client performs an intermixed sequence of (queue) enqueueand dequeue operations. The enqueue operations put the integers 0 through 9 inorderon to the queue; thedequeue operations print out the returnvalue. Which ofthe followingsequence(s) could notoccur?

a. 0123456789

b. 4687532901

a 2567489310

d. 4321056789

4.3.17 Write an iterable Stack client that has a static method copy () that takes astackof stringsas argument and returns a copyof the stack. Note: This abilityis aprime example of thevalue of having an iterator, because it allows development ofsuch functionality without changing the basic API. See Exercise 4.3.47 for a betterinterface.


4.3.18 Develop a class Doubl i ngQueueOfSt ri ngs that implements the queue abstractionwith a fixed-size array, and then extendyour implementationto use arraydoubling to remove the size restriction.

4.3.19 Write a Queue clientthat takes a command-line argumentk prints the kthfrom the last string found on standard input.

4.3.20 (Forthe mathematically inclined.) Prove that thearrayin Doubl i ngStackOfStri ngs is neverless than one-quarter full. Then prove that, for any Doubl i ngStackOfSt ri ngs client, the total cost of all of the stackoperations dividedby thenumber of operations is a constant.

4.3.21 Modify MDlQueue to make a program MMlQueue that simulates a queuefor which both arrival and service are Poisson processes. Verify Little's lawfor thismodel.

4.3.22 Develop a class StackOfInts that usesa linked-list representation (but nogenerics). Write a client that compares the performance of your implementationwith Stack<Integer> to determine the performance penaltyfrom autoboxing onyour system.

599


Tfttk^St^1^^^^^*1^!^

This listofexercises is intended togive youexperience in working with linked lists. Theeasiest way towork them istomake drawings using the visual representation describedin the text

4.3.23 Writea method del ete () that takesan i nt argument k and deletes the kthelement in a linked list, if it exists.

4.3.24 Write a method find() that takes a linked list and a string key as arguments and returns true if some node in the list has key as its item field, falseotherwise.

4.3.25 Suppose x is a linked-list node. What is the effect of the following codefragment?

x.next = x.next.next;

Answer: Deletes from the list the node immediately following x.

4.3.26 Supposethat x is a linkedlistnode.What does the following code fragmentdo?

t.next = x.next;

x.next = t;

Answer: Inserts node t immediatelyafter node x.

4.3.27 Why does the following code fragment not do the same thing as in theprevious question?

x.next = t;

t.next = x.next;

Answer: When it comes time to update t. next, x. next is no longer the originalnode following x, but is instead t itself!

4.3.28 Write a method removeAfterO that takes a linked-list Node as argumentand removes the node following the given one (and does nothing if the argumentor the next field in the argument node is null).


4.3.29 Writea method i nsertAfter () that takes twolinked-list Node argumentsand insertsthe secondafterthe firston itslist (anddoesnothingif eitherargumentis null).

4.3.30 Write a method remove () that takes a linkedlist and a string key as arguments and removes all of the nodes in the list that have key as its item field.

4.3.31 Write a method max() that takes a reference to the first node in a linked listas argument and returns the value of the maximum keyin the list.Assume that allkeys are positive integers, and return 0 if the list is empty.

4.3.32 Develop a recursive solution to the previousquestion.

4.3.33 Write a recursive method to print the elements of a linked list in reverseorder. Do not modify any of the links. Easy: Use quadratic time, constant extraspace. Also easy: Uselinear time, linear extra space. Notsoeasy: Develop a divide-and-conquer algorithmthat uses linearithmic time and logarithmic extra space.

4.3.34 Write a recursive method to randomly shuffle the elements of a linked listbymodifying the links. Easy: Use quadratic time,constantextraspace. Notsoeasy::Develop a divide-and-conquer algorithm that uses linearithmic time and logarithmic extra space.


4.3.35 Deque. A double-ended queue ordeque (pronounced deck) isacombination of a stack and and a queue. It stores a collection of items and supports thefollowing API:

public class Deque<Item>

Deque()

boolean isEmpty()


void push(Item item)

Item pop()

Item dequeue()

create an emptydeque

is thedequeempty?

add an item to the end

add an item to the beginning

remove an itemfrom thebeginning

remove an itemfrom theend

APIfor a generic double-ended queue

Write a class Deque that uses a linked list to implement this API.

4.3.36 Random queue. A random queue stores acollection of items and supportsthe following API:

public class RandomQueue<Item>

RandomQueue()

boolean isEmptyO


Item dequeueO

Item sample()

create an empty random queue

is thequeueempty?

add an item

remove and return a random item

(sample without replacement)

return a random item, but do not remove(sample with replacement)

APIfor a generic random queue

Write a classRandomQueue that implements this API. Hint: Use an arrayrepresentation (with doubling). To remove an item, swap one at a random position (indexed0 through N-l) with the oneatthe last position(index N-l). Then delete andreturn


the last object, as in Doubl i ngStack. Write a client that prints a deck of cards inrandom order using RandomQueue<Card>.

4.3.37 Random iterator. Write an iterator for RandomQueue<Item> from the previous exercise that returns the items in random order. Note: This exercise is more

difficult than it looks.

4.3.38 Josephus problem. In the Josephus problem from antiquity,N people arein dire straits and agree to the following strategy to reduce the population. Theyarrange themselves in a circle (at positions numbered from 0 to N—l) and proceedaround the circle,eliminating everyMth person until only one person is left. Legend has it that Josephusfiguredout where to sit to avoidbeing eliminated.Write aQueue client Josephus that takesN and M from the command line and prints outthe order in which people are eliminated (and thus would showJosephuswhere tosit in the circle).

% Java Josephus 7 213 5 0 4 2 6

4.3.39 Delete ithelement. Implement a class that supports the following API:

public class GeneralizedQueue<Item>

GeneralizedQueue()

boolean isEmptyO

void insert(Item item)

Item delete (int i)


is thequeue empty?

add an item

delete and return the i th leastrecentlyinserted item

APIfor a generic generalized queue

First, develop an implementation that uses an array implementation, and then develop one that uses a linked-list implementation. (See Exercise 4.4.48 for a moreefficient implementation that uses a BST.)


4.3.40 Ring buffer. A ring buffer, or circular queue, is a FIFO data structure of afixed sizeN. It isusefulfor transferringdata betweenasynchronousprocesses or forstoring log files. When the buffer is empty, the consumer waits until data is deposited;when the buffer isfull, the producerwaitsto depositdata.Develop anAPIfor aringbufferand an implementation that uses an arrayrepresentation (withcircularwrap-around).

4.3.41 Merging two sorted queues. Given two queues with strings in ascendingorder, move all of the strings to a third queue so that the third queue ends up withthe strings in ascendingorder.

4.3.42 Nonrecursive mergesort. Given N strings, createN queues, each containingone of the strings.Createa queueof theN queues. Then, repeatedlyapplythe sortedmerging operationto the firsttwoqueues and reinsertthe mergedqueueat the end.Repeatuntil the queue of queues contains only one queue.

4.3.43 Queue with two stacks. Showhow to implement a queue using two stacks.Hint: If you push elements onto a stack and then pop them all, they appear in reverseorder. Repeatingthe processputs them back in FIFO order.

4.3.44 Move-to-front. Readin a sequence of charactersfrom standard input andmaintain the characters in a linked list with no duplicates. When you read in apreviouslyunseen character, insert it at the front of the list.When you read in a duplicate character, delete it from the list and reinsert it at the beginning. Name yourprogram MoveToFront: it implementsthe well-know move-to-front strategy, whichis useful for caching, data compression, and many other applications where itemsthat havebeen recently accessed are more likelyto be reaccessed.

4.3.45 Topological sort. You have to sequence the order of Njobs that are numbered from 0 to N-l on a server. Some of the jobs must complete before otherscan begin. Write a program Topological Sorter that takes Nas a command-lineargument and a sequence on standard input of ordered pairs of jobs i j, and thenprints a sequence of integers such that for each pair i j in the input, job i appearsbefore job j. Use the following algorithm: First, from the input, build, for each job,(i) a queue of the jobs that must follow it and (ii) its indegree (the number of jobs


that must come before it). Then, build a queue of all nodes whose indegree is 0 andrepeatedly delete some job with zero indegree,maintaining all the data structures.This process has many applications: for example, you can use it to model courseprerequisites for your major so that you can find a sequence of courses to take inorder to graduate.

4.3.46 Text editor buffer. Develop a data type for a buffer in a text editor thatimplements the following API:

public class Buffer

Buffer()

void insert(char c)

char deleteO

void left (int k)

void right (int k)

int sizeQ

create an empty buffer

insert c at thecursor position

delete and return the character at the cursor

move thecursor k positions to theleft

move thecursor k positions to theright

number of characters in thebuffer

APIfor a text buffer

Hint: Use two stacks.

4.3.47 Copy a stack. Create a new constructor for the linked list implementationof Stack so that

Stack<Item> t = new Stack<Item>(s);

makes t a reference to a new and independent copy of the stack s. You should beable to push and pop from either s or t without influencingthe other.

4.3.48 Copy a queue. Create a new constructor so that

Queue<Item> r = new Queue<Item>(q);

makes r a reference to a new and independent copy of the queue q. Hint: Delete allof the elements from q and add these elements to both q and r.


4.3.49 Reverse a linked list. Write a function that takes the first Node in a linked

list as argument and reverses the list, returning the first Node in the result.

Iterative solution: To accomplish this task, we maintain references to three consecutive nodes in the linked list, reverse, f i rst, and second. At each iteration, we

extract the node f i rst from the original linked list and insert it at the beginningof the reversed list. We maintain the invariant that f i rst is the first node ofwhat's

left of the original list, second is the second node of what's left of the original list,and reverse is the first node of the resulting reversedlist.

public Node reverse(Node list){

Node first = list;Node reverse = null;while (first != null) {

Node second = first.next;first.next = reverse;reverse = first;first = second;

}

}

return reverse;

When writing code involving linked lists, we must always be careful to properlyhandle the exceptional cases (when the linked list is empty, when the list has onlyone or two nodes) and the boundary cases (dealing with the first or last items). Thisis usually much trickier than handling the normal cases.

Recursive solution: Assuming the linked list has N elements, we recursivelyreversethe last N— 1 elements, and then carefully append the first element to the end.


public Node reverse(Node first){

}

Node second

Node rest =

second.next = first;first.next = null;return rest;

= first.next;reverse(second);

4.3.50 Queue simulations. Study what happens when you modify MDlQueue touse a stack instead of a queue. Does Little's law hold? Answer the same questionfor a random queue. Plot histograms and compare the standard deviations of thewaiting times.

4.3.51 More queue simulations. Instrument LoadBal ance to print the averagequeue length and the maximum queue length instead of plotting the histogram,and use it to run simulations for 1million items on 100,000 queues. Print the average valueof the maximum queue length for 100trials eachwith sample sizes 1,2,3,and 4. Do your experiments validate the conclusion drawn in the text about usinga sample of size 2?

4.3.52 Listingfiles. A folder is a list of files and folders. Write a program that takesthe name ofa folder asacommand-line argument and prints out allofthe files contained in that folder, with the contents of each folder recursivelylisted (indented)under that folder's name. Hint: Use a queue, and see j ava. i o. Fi1e.

607


4.4 Symbol Tables

A symbol table is a data type that we use to associate values with keys. Clients canstore (put) an entry into the symbol table by specifying a key-value pair and thencan retrieve (get) the value correspond-ing to aparticular key from the symbol 441 Dictionarylookup 614table. For example, a university might 4.4.2 indexing 617associate information such as a student's 4.4.3 BST symbol table 625name, home address, and grades (the 4AA Dedup filter ..'...' 633value) with that student's social security Programs inthis sectionnumber (the key), so that each student'srecord can be accessed by specifying a Social Security number. The same approach might be appropriate for a scientist whoneeds to organize data, a business that needs to keep track of customer transactions, an internet search engine that has to associate keywords with web pages, orin countless other ways.

Because of their fundamental importance, symbol tables have been heavilyused and studied since the early days of computing. The development of implementations that guarantee good performance continues to be an active area of research interest. Several other operations on symbol tables beyond the characteristicput and get operations naturally arise, and guaranteeing good performance for agiven set of operations can be quite challenging.

In this chapter we consider a basic API for the symbol-table data type and aclassic implementation of that API.Our API adds to the put and getoperations theabilities to test whether any value has been associatedwith a given key (contains)and to iterate through the keys in the table in order.

The implementation that we consider is based on a data structure known asthe binary search tree (BST). It is a remarkably simple solution that performs wellin many practical situations and also serves as the basis for the industrial-strengthsymbol-table implementations that are found in modern programming environments. The BST code that we consider for symbol tables is only slightly more complicated than the linked-list code that we considered for stacks and queues, but itwill introduce you to a new dimension in structuring data that has far-reachingimpact.


API A symbol table is a collection of key-valuepairs. We use a generic type Keyfor keysand a generic type Value for values—every symbol-table entry associatesaValue with a Key. In most applications,the keys havesome natural ordering, so (aswe did with sorting) we require the key type Key to implement Java's Comparableinterface. These assumptions lead to the followingbasic API:

public class *ST<Key extends Comparable<Key>, Value>

*ST() create a symbol table

void put (Key key, Value v) putkey-value pair into the table

Val ue get (Key key) return value paired with key, nul 1 if key notin table

bool ean COntai ns (Key key) is there a value paired with key?

Note: Implementations should alsoimplement theIterabl e<Key> interface to enable clients to accesskeys in sorted order withforeach loops.

APIfor a generic symbol table

As usual, the asterisk is a placeholder to indicate that multiple implementationsmight be considered. In this section, we provide one basic implementation BST (wedescribe some elementary implementations briefly in the text and some other implementations in the exercises). ThisAPI reflects severaldesign decisions,which wenow enumerate.

Comparable keys. Asyou will see, we take advantage of keyordering to developefficient implementations of put and get. An even more basic symbol-table API,suitable for some applications, might omit extends Comparable. Since keys inmost applications are numbers or strings, this requirement is generally not restrictive.

Immutable keys. We assume the keys do not change their value while in the symbol table. The simplest and most commonly used types of keys,Stri ng and built-in wrapper types such as Integer and Doubl e, are immutable.

Replace-the-old-value policy. If a key-value pair is insertedinto the symboltablethat already associates another value with the given key, we adopt the convention


that the new value replaces the old one (just as with an array assignment statement). The contai ns() method gives the client the flexibility to avoiddoing so, ifdesired.

Notfound. The method get() returns null if no entry with the given key haspreviously been put into the table. This choice has two implications, discussednext.

Null keys andvalues. Clients arenot permittedto usenul1 asa keyor value. Thisconvention enables us to implement contai ns() as follows:

public boolean contains(Key key){ return get(key) != null; }

Remove. We do not include a method for removing keys from the symbol table.Many applications do require such a method, but we leave implementations as anexercise (see Exercise 4.4.13) or for a more advanced course in data structures inalgorithms.

Iterable. As indicated in the note in theAPI, we assume that the data type implements the Iterabl e interfaceto provide an appropriate iterator that allows clientsto visit the contents of the table. Since keys are Comparable, the natural order ofiteration is in order of the keys. Accordingly, we will implement Iterabl e<Key>and clients can useget to get valuesassociatedwith keys if desired.

Variations. Computerscientists have identified numerous other useful operationson symbol tables, and APIs based on various subsets of them have been widelystudied. Weconsider severalof these operations at the end of this section.

Symboltablesare among the most widely studied data structures in computer science, so the impact of these and many alternative design decisions has been carefully studied, as you will learn if you take later courses in computer science. Inthis chapter, our approachis to introduceyou to the most important propertiesofsymboltables by considering twoprototypical clientprograms,developing an efficient implementation,and studyingthe performancecharacteristics of that implementation, to show you that it can meet the needs of typical clients,even when thetables are huge.


Symbol table clients Once you gain some experience with the idea, you willfind that symbol tables are broadly useful. To convince you of this fact, we startwith two prototypicalexamples, eachof whicharises in a large number of important and familiar practical applications.

Dictionary lookup. The most basic kind of symbol-table client builds a symboltable with successiveput operations in order to support getrequests.Wemaintain acollectionof data so that we can quicklyaccess the data weneed. Most applicationsalso take advantageof the idea that a symboltable is a dynamic dictionary,where itis easyto look up information andto update the information in the table. The followinglist of familiar examples illustratesthe utility of this approach.

• Phone book. When keysare people'snames and valuesare their phone numbers, a symbol table models a phone book. A very significant differencefrom a printed phone book is that wecan add newnamesor changeexistingphone numbers. We could also use the phone number as the key and thename as the value.If you haveneverdone so,try typingyour phone number(with area code) into the search field in your browser.

• Dictionary. Associating a word with its definition is a familiar concept thatgives us the name "dictionary." For centuries peoplekept printed dictionaries in their homes and officesin order to check the definitions and spellings(values) of words (keys). Now, because of good symbol-table implementations, people expect built-in spell checkers and immediate access to worddefinitions on their computers.

• Account information. People who own stock now regularly check the current price on the web. Several services on the web associate a ticker symbol(key) with the current price (value), usually alongwith a greatdeal of otherinformation. Commercialapplications of this sort abound, including financial institutions associating account information with a name or accountnumber or educational institutions associatinggrades with a student nameor identification number.

• Genomics. Symbols playa central role in modern genomics, as we have alreadyseen (seeProgram 3.1.8).The simplestexampleis the use of the lettersA, C, T,and Gto represent the nucleotides found in the DNA of living organisms.The next simplest is the correspondence betweencodons (nucleotidetriplets) and amino acids (TTA corresponds to leucine, TCT to cycstine, andso forth), then the correspondence between sequences of amino acids and


proteins, and so forth. Researchers in genomics routinely usevarious typesof symbol tables to organize thisknowledge.

•Experimental data. From astrophysics to zoology, modern scientists areawash in experimental data, and organizing and efficiently accessing thisdata is vital to understanding what it means. Symbol tables are a criticalstarting point, and advanced data structures and algorithms that are basedon symbol tables are now an important part of scientificresearch.

•Programming languages. One of the earliest uses of symbol tables was toorganize information for programming. At first, programs were simplysequences of numbers,but programmers veryquickly found that using symbolic names for operations and memory locations (variable names) wasfar more convenient. Associatingthe names with the numbers re- ^ey va\uequires a symbol table. As the sizeof programs grew,the cost of thesymbol-table operations becamea bottleneck in program development time, which led to the de

velopment of data structures andalgorithms like the one we consider in this section.

•Files. We use symbol tables regularly to organize data on computer systems. Perhaps the mostprominent example is the filesystem, where we associate a file name (key) with the location of its contents (value). Your music player uses the samesystem to associate songtitles(keys)with the location of the music itself (value).Internet DNS. The domain name system (DNS) that is the basis for organizing information on the internet associates URLs (keys) that humansunderstand (such as www.princeton.edu or www.wikipedia.org) withIP addresses (values) that computer network routers understand (such as208.216.181.15 or 207.142.131.206). This system is the next-generation"phonebook." Thus,humanscanusenames that are easy to remember andmachines can efficiently process the numbers.The number of symbol-tablelookups done each second for this purpose on internet routers around the

phone book name phone number

dictionary word definition

account account number balance

genomics codon amino acid

data data/time results

Java compiler variable name memory location

file share song name machine

internet DNS website IP address

Typical dictionary applications

4.4 Symbol Tables

world is huge, so performance is of obvious importance. Millions of new computers and otherdevices are put onto the internet each year, sothese symbol tables on internet routers need to bedynamic.

Despite its scope, this list is still just a representativesample, intended to give you a flavor of the scope ofapplicability of the symbol-table abstraction. Wheneveryou specifysomething by name, there is a symboltable at work. Your computer's file system or the webmight do the work for you, but there is still a symboltable there somewhere.

For example, to build a table associating codonswith amino acid names, we can write code like this:

ST<String, String> amino;amino = new ST<String, String>();ami no.put("TTA", "leucine");

The idea of associating information with a key is sofundamental that many high-level languages have abuilt-in support for associative arrays, where you canuse standard array syntax but with keys inside thebrackets instead of an integer index. In such a language, you could write ami no["TTA"] = "1euci ne"instead of ami no. put("TTA", "1euci ne"). AlthoughJava does not (yet) support such syntax, thinking interms of associativearrays is a good wayto understandthe basic purpose of symbol tables.

Lookup (Program 4.4.1) builds a set of key-valuepairs from a file of comma-separated values (see Section 3.1) as specified on the command line and thenprints out values corresponding to keys read fromstandard input. The command-line arguments are thefile name and two integers, one specifying the field toserve as the key and the other specifying the field to

% more amino.csv

TTT,Phe,F,Phenylalani neTTC,Phe,F,Phenylalani neTTA,Leu,L,LeucineTTG,Leu,L,LeucineTCT,Ser,S,SerineTCC,Ser,S,SerineTCA,Ser,S,SerineTCG,Ser,S,SerineTAT,Tyr,Y,TyrosineTAC,Tyr,Y,TyrosineTAA,Stop,Stop,Stop

GCA.AlaGCG,AlaGAT,AspGAC,AspGAA.GlyGAG.GlyGGT.GlyGGCGlyGGA,GlyGGG,Gly

,A,Alanine,A,Alanine,D,Aspartic Acid,D,Aspartic Acid,G,Glutamic Acid,G,Glutamic Acid,G,Glycine,G,Glycine,G,Glycine,G,Glycine

613

% more DDIA.csv

20-0ct-87,1738.74,608099968,1841.0119-0ct-87,2164.16,604300032,1738.7416-0ct-87,2355.09,338500000,2246.7315-Oct-87,2412.70,263200000,2355.09

30-Oct-29,230.98,10730000,258.4729-0ct-29,252.38,16410000,230.0728-Oct-29,295.18,9210000,260.6425-Oct-29,299.47,5920000,301.22

% more np.csv

www.ebay.com,66.135.192.87www.pri nceton.edu,128.112.128.15www.cs.pri nceton.edu,128.112.136.35www.harvard.edu,128.103.60.24www.yale.edu,130.132.51.8www.cnn.com,64.236.16.20www.google.com,216.239.41.99www.nyti mes.com,199.239.136.200www.apple.com,17.112.152.32www.siashdot.org,66.35.250.151www.espn.com,199.181.135.201www.weathe r.com,63.Ill.66.11www.yahoo.com,216.109.118.65

Typical comma-separated-value (CSV) files


M

.'•s:;',&&1

l

^.it:;M.^:-^& •: ."'^-vh^v* ^^:;:^^^:^^^:^i^v<^'&

Program 4.4.1 Dictionary lookup

public class Lookup{

public static void main(String[] args){ // Build dictionary, provide values for keys in Stdln.

In in = new In(args[0]);int keyField = Integer.parselnt(args[1]);int valField = Integer.parselnt(args[2]);

String[] database = in.readAn().split("\n");StdRandom.shuff1e(database);

BST<String, String> st = new BST<String, String>();for (int i = 0; i < database.length; i++){

ft

}

// Extract key, value from one line and add to ST.String[] tokens = database[i].split(",");String key = tokens[keyField];String val = tokens[valField]; inst. put (key, val); keyField

valFi eld

database[]

st

tokens

key

val

while (!Stdln.isEmptyO){ // Read key and provide value.

String s = Stdln.readStringO;if (st.contains(s))

StdOut.println(st.get(s));else StdOut.println("Not found");

}

input stream (.csv)

key position

valueposition

linesin input

symboltable(BST)

values on a line

key

value

query

}i^WiWPSaS>3«??p5SwlS§§!

This data-driven symbol table client reads key-value pairs from a comma-separated file, thenprints out values corresponding to keys on standard input. Both keys and values are strings.

^^^^^^m^^^^^^^^m^^^w^^^^^^^v^^^^^^

% Java Lookup ami no.csv 0 3TTA

Leucine

ABC

Not found

TCT

Serine

% Java Lookup ami no.csv 3 0GlycineGGG

^1S1SP!PP ^wSJ^SSS^-S

% Java Lookup ip.csv 0 1www.google.com216.239.41.99

% Java Lookup ip.csv 1 0216.239.41.99

www.google.com

% Java Lookup DJIA.csv 0 129-0ct-29

252.38

4JJPM8 ^^jjswF^I^


serveas the value. Examples of similar but slightly more sophisticated test clientsare described in the exercises. For instance, we could make the dictionary dynamicby also allowing standard-input commands to change the value associated with akey (see Exercise 4.4.1).

Your first step in understanding symboltables is to download Lookup. Javaand BST. java (the symbol-table implementation that weconsider next) from thebooksite to do some symbol-table searches. You can find numerous comma-sep-arated-value (. csv) files that are related to various applications that we have described, including ami no. csv (codon-to-amino-acid encodings), DJIA. csv (openingprice, volume, and closing priceof the stock market average, for every dayin itshistory), and i p. csv (a selection of entries fromthe DNS database). When choosingwhich field to use as the key, remember that each key must uniquely determinea value. If there are multiple putoperations to associate values with a key, the tablewill remember only the most recentone (think about associative arrays). Wewillconsider next the casewhere we want to associatemultiple values with a key.

Laterin this chapter,wewillseethat the costof theputoperations and the getrequests in Lookup is logarithmic in the size of the table. Thisfact implies that youmayexperience a smalldelaygettingthe answer to your firstrequest (for alltheputoperationsto build the table), but you getimmediate response for all the others.

Indexing. Index (Program 4.4.2) is a prototypical example of a symbol-table client that usesan intermixedsequence of calls to get () and put (): it reads in a listof stringsfrom standard input and prints a sorted tableof all the different stringsalongwith a list of integers specifying the positions where eachstring appeared inthe input. Wehavea large amount of data and want to knowwhere certain stringsof interest occur. In this case,we seem to be associatingmultiple values with eachkey, but weactually associating just one: a queue. Again, this approach is familiar:

• Book index. Every textbook has an indexwhereyou look up a word and getthe page numbers containing that word.Whileno reader wants to see everyword in the book in an index, a program like Index can provide a startingpoint for creating a good index.

• Programming languages. In a large program that uses a large numberof symbols, it is useful to know where each name is used. A program like Indexcan be a valuable tool to help programmers keep track of where symbolsare used in their programs. Historically, an explicit printed symbol tablewas one of the most important tools used by programmers to manage large


programs. In modern systems, symbol tables are the basis of software toolsthat programmers useto manage names of modules in systems.

• Genomics. In a typical (if oversimplified) scenario in genomics research, ascientist wants to knowthe positions of a given genetic sequence in an existinggenome or setof genomes. Existence or proximity of certain sequencesmaybe of scientific significance. The startingpoint for such research is anindexlikethe one producedby Index, modifiedto take into account the factthat genomesare not separated into words.

• Web search. When youtype a keyword and get a listof websites containingthat keyword, you are using an index created by your web search engine.There is one value (thelistof pages) associated with each key (the query),although the reality isabit moredynamic and complicated because weoftenspecify multiple keys and the pages arespread through the web, not kept ina table on a single computer.

•Account information. One way for a companythat maintains customer accounts to keep track of a day's transactions is to keepan index of the list ofthe transactions. The key is the account number; the value is the list of oc

currences of that account number in the

transaction list.key value

book term pagenumbers

genomics DNA substring locations

web search keyword websites

business customer name transactions

Index (Program 4.4.2) takes three command-line arguments: a file name and twointegers. The first integer is the minimumstring length to include in the symbol table,and the second is the minimum number of

occurrences (among the words that appearin the text) to include in the printed index. Again, several similar clients for various useful tasks are discussed in the exercises. Forexample, one common scenariois to build multiple indices on the same data, using different keys. In our accountexample, one index might use customer account numbers for keys and anothermight use vendor account numbers.

Aswith Lookup, you are certainly encouraged to download Index from thebooksite andrun it onvarious inputfiles togain further appreciation fortheutilityof symbol tables. Ifyou do so, you will find that it canbuild large indices forhugefiles withlittle delay, because each putoperation andgetrequest istaken care of immediately. Providing thisimmediate response forhuge dynamic tables isoneof theclassic contributions of algorithmic technology.

Typical indexingapplications


tiJ

m

I

?%i

Program 4.4.2 Indexing

public class Index{


int mini en = Integer.parselnt(args[0]);int minocc = Integer.parselnt(args[1]);

String[] words = Stdln. readAll Q .split(,,\\s+") ;

BST<String, Queue<Integer» st;st = new BST<String, Queue<Integer»();

for (int i =0; i < words.length; i++){ // Add word position to data structure.

String s = words[i];if (s.lengthO < mini en) continue;if (1st.contains(s))

st.put(s, new Queue<Integer>());Queue<Integer> q = st.get(s);q.enqueue(i);

}

for (String s : st){ // Print words whose occurrence count exceeds threshold.

Queue<Integer> q = st.get(s);if (q.length() >= minocc)

StdOut.println(s + ": " + q);

}

mini en

mi nocc

words []

st

minimumlength

occurence threshold

words in Stdln

symbol table

current word

queueofpositionsfor current word

P£••;

ITThis symbol table client indexes a textfile by word position. Keys are words, and values arequeues ofpositions where theword occurs in thefile.

Java Index 9 30 < TaleOfTwoCities.txtconfidence: 2794 23064 25031 34249 47907 48268 48577

courtyard: 11885 12062 17303 17451 32404 32522 38663evremonde: 86211 90791 90798 90802 90814 90822 90856

expression: 3777 5575 6574 7116 7195 8509 8928 15015gentleman: 2521 5290 5337 5698 6235 6301 6326 6338 ..influence: 27809 36881 43141 43150 48308 54049 54067

monseigneur: 85 90 36587 36590 36611 36636 36643 ...prisoners: 1012 20729 20770 21240 22123 22209 22590 .something: 3406 3765 9283 13234 13239 15245 20257 ...sometimes: 4514 4530 4548 6082 20731 33883 34239 ...

vengeance: 56041 63943 67705 79351 79941 79945 80225

,^^BBsR^^ffl^^^^W^^wvS&f-isi^?s*8s¥*3a!Spp M^^^^^S^^^^^^^^^^^W^^^^^^^


Symbol table implementations All of these examples are certainly persuasive evidence of the importance of symbol tables. Symbol-table implementations

have been heavily studied, many different algorithms and datastructures have been invented for this purpose, and modernprogramming environments (including Java) have several different symbol-table implementations. You are going to learn aremarkablysimpleone that serves as the basis for many others.Asusual,knowinghow a basic implementation workswillhelpyou appreciate, chooseamong, and more effectively use the advanced ones, or helpimplementyour ownversionfor somespecialized situation that you might encounter.

One reason for the proliferation of algorithms and implementations is that the needs of symbol-table clients can varywidely. On the one hand, when the symbol table or the numberof operations to be performed is small,any implementation willdo. On the other hand, symbol tables for some applications areso huge that they are organized as databases that reside on external storage or the web. In this section, we focus on the hugeclass of clients like Index and Lookup whose needs fall betweenthese extremes, where we need to be able to use put operationsto build and maintain large tables dynamically while also responding immediately to a large number of get requests.

We already considered the idea of a dictionary when weconsidered binary search in Section 4.2. It is not difficult tobuild a symbol-table implementation that is based on binarysearch (see Exercise 4.4.5) but such an implementation is notfeasible for use with a client like Index, because it depends onmaintaining an array sorted in order of the keys. Each time anew key is added, larger keys have to be shifted one positionhigher in the array, which implies that the total time required tobuild the table is quadratic in the size of the table.

Alternatively, we might consider basing an implementation on an unordered linked list. But such an implementationis also not feasible for use with a client like Lookup or Index,

because the only way to search for a key in a list is to traverse its links, so the totaltime required for searches is the product of the number of searches and the size of

put CATinto/ the array

AAA

/

AAA

AAC

AAG

AAC

AAG

AAT

ACT

ATA

ATC

ATG

AGG

AGT

CAG

CCT

CGA

CGC

CGG

CGT

CTT

GAA

GAC

GAG

GAT

GCT

GGA

GTC

GTG

GTT

TAA

TAC

TAG

TAT

TCA

TGT

TTA

TTC

TTG

TTT

AAT

ACT

ATA

ATC

ATG

AGG

AGT

CAG

CAT

CCT

CGA

CGC

CGG

CGT

CTT

GAA

GAC

GAG

GAT

GCT

GGA

GTC

GTG

GTT

TAA

TAC

TAG

TAT

TCA

TGT

TTA

TTC

TTG

TTT

largerkeysall have to move

Put into a sortedarraytakes linear time


unordered

ccc CCT ^-^ AAA ACT->

ACT^r CCC CCC

->

Meed togo throughwhole list to know

thatany keyis not thereTAG

Ga

CGC

null

key-sorted order

ATG GAA^

GTTJ-

MCfl

GGG^ GTT

^ TAG^>

needtogo throughnearly thewholelist tofind

keysneartheendca

Get in a linked list takes linear time

the table,which again is prohibitive.Implementingput is alsoslowbecausewehaveto searchfirst to avoidputting duplicatekeys in the symboltable.Even keeping thelist in sorted order does not help much—for example,traversing all the links is stillrequired to add a new node to the end of the list.

Toimplement a symbol-tablethat is feasible for usewith clientssuch as Lookup and Index, we need the flexibility of linked lists and the efficiency of binarysearch.Next,we consider a data structure that provides this combination.

Binary search trees The binary tree is a mathematical abstraction that playsa central role in the efficient organization of information. Like arrays and linkedlists,a binary tree is a data type that storesa collection of data. Binarytrees playanimportant role in computer programming because they strike an efficient balancebetween flexibilityand ease of implementation.

For symbol-table implementations, we use a specialtype of binary tree to organize the data and to provide a basisfor efficient implementationsof the symbol-table put operations and get requests. A binary search tree (BST) associates comparable keys with values, in a structure defined recursively. A BST is one of thefollowing:

• Empty (null)• A node having a key-value pair and two references to BSTs, a left BST with

smaller keysand a right BST with larger keysThe key type must implement Comparabl e, but the type of the value is not specified, so a BST node can hold any kind of data in addition to the (characteristic)references to BSTs. As with our linked-list definition in Section 4.3, the idea of a

recursivedata structure can be a bit mind bending, but allwe are doing is adding asecond link (and imposing an ordering restriction) to our linked-list definition.


To implement BSTs, we start with a class for the nodeabstraction, which hasreferences to a key, a value, and left and right BST:

class Node

{Key key;Value val;Node left, right;

}

This definitionis likeour definition of nodes for linkedlists, except that it has twolinks, not just one. From the recursive definition of BSTs, we can representa BSTwith a variable of type Node by ensuring that its value is either nul1 or a referenceto a Node whose 1eft and ri ght fields arereferences to BSTs, and by ensuring that theordering condition is satisfied (keys in theleftBST are smallerthan keyand keys in theright BST are larger than key).To (slightly)simplify the code, we add a constructor toNode that initializes key and val:

Node(Key key, Value val){

this.key = key;this.val = val;

}

Binarysearch tree

The result of new Node (key, val) is a reference to a Node object (whichwe canassign to any variable of type Node) whose key and val instance variables are set tothe given values and whose 1eft and ri ght instance variables are both initializedto null.

As with linked lists, when tracing code that uses BSTs, we can use a visualrepresentation of the changes:

• Wedraw a rectangleto representeach object.• Weput the valuesof instancevariables within the rectangle.• Wedepict references as arrows that point to the referenced object.

Most often, we use an even simpler abstract representation where we draw rectangles containingkeys to representnodes (suppressing the values) and connect thenodes with arrows that represent links. This abstract representation allows us tofocus on the structure.

4.4 Symbol Tables

For example, suppose that Key is String and Value is Integer. To build aone-node BSTthat associates the key i t with the value 0, we just create a Node:

Node first = new NodeC'it", 0);

Sincethe left and right links are both null, both refer to BSTs, so this node is a BST.To add a node that associates the key was with the value 1, we create anotherNode:

621

Node first = new NodeC'it", 0);

Node second = new Node("wasM, 1);

(which itself is a BST) and link to it from the right field ofthe first Node

first.right = second;

The second node has to go to the right of the first becausewas comes after i t in Comparabl e order (or we could havechosen to set second. 1eft to fi rst). Now we can add athird node that associates the key the with the value 2 withthe code:

Node third = new NodeC'the", 2);second.left = third;

and a fourth node that associates the key best with thevalue 3 with the code

Node fourth = new NodeC'best", 3);first.left = fourth;

Note that each of our links—fi rst, second, thi rd, and

fourth—are, by definition, BSTs (they each are either nullor refer to BSTs, and the ordering condition is satisfied ateach node).

We often use tree-based terminology when discussing BSTs. We refer to the node at the top as the rootof thetree, the node referenced by its left link as the leftsubtree,and the node referenced by its right link as the right subtree.Traditionally, computer scientists draw trees upside down,with the root at the top. Nodes whose links are both null are called leafnodes. In

ull\»u"\

Node second

first.right

new Node("was"

second;

t-nnof i—first

"•^|jwas |ll| null\nulll

1);

Node third= new Node("the", 2);

second.left = third;

Node fourth

first.left =

= new NodeC'best", 2);

fourth;

Linking together a BST


general, a tree may have multiple links per node,the order of the links maynot besignificant, and no keys or values in the nodes. General trees have many applications in science, mathematics, and computational applications, so you are certainto encounter the model on many occasions.

In the present context, we take care to ensure that we always link togethernodes such that every Node that we create is the root of a BST (has a key,avalue, alink to aleft BSTwith smaller values, and alink to a right BST with a larger value).From the standpoint of the BST data structure, the value is immaterial, so we oftenignore it, but we include it in the definition because it plays such a central role inthe symbol-table concept. We also intentionally confuse our nomenclature, usingSTto signifyboth "symbol table" and"search tree" because search trees playsuch acentral role in symbol-table implementations.

A BST represents an ordered sequence of items. In the example just considered, f i rst represents the sequence best i t the was. We canalso use an array torepresent a sequence of items. Forexample, we could use:

String[] a = { "best", "it", "the", "was" };

to represent the sameordered sequence of strings. Givenasetofdistinctkeys, thereis only one way to represent them in an ordered array, but there are many waysto represent it in a BST (see Exercise4.4.7). Thisflexibility allows us to develop efficient symbol-table implementations. For instance, in our example we were able to insert each new item bycreating a new node and changing just one link.As it turns out, it is always possible to do so.Equallyimportant, we can easily find a givenkeyin the tree and find the place where we need toadd a link to a new node with a given key. Next,we considersymbol-table code that accomplishes these tasks.

Suppose that you want to search for a nodewith a givenkey in a BST (or to getavaluewith agivenkey in a symbol table). There are two possible outcomes: the search might be successful(we find the key in the BST; in a symbol-tableimplementation, we return the associatedvalue)

Two BSTs representing the same sequence


or it might be unsuccessful (there is no key in the BST with the given key; in asymbol-table implementation, we return null).

A recursive searching algorithm is immediate: Given a BST (a reference toa Node), first check whether the tree is empty (the reference is null). If so, thenterminate the search as unsuccessful (in a symbol-table implementation, returnnul 1). If the tree is nonempty, check whether the key in the node is equal to thesearch key. If so, then terminate the search as successful (in a symbol-table implementation, return the value associatedwith the key).If not, compare the search keywith the key in the node. If it is smaller, search (recursively) in the left subtree; if itis greater, search (recursively) in the right subtree.

Thinking recursively, it is not difficult to become convinced that this methodbehaves as intended, based upon the invariant that the key is in the BSTif and onlyif it is in the current subtree. The key property of the recursive method is that wealways have just one node to examine in order to decide what to do next. Moreover,we typically examine only a small number of the nodes in the tree: whenever wego to one of the subtrees at a node, we neverwill examineany of the nodes in theother subtree.

successful search unsuccessful searchfora node with key the fora node with key ti mes

times isafter itsogo to theright

the isafter itbest

so go to the right ["'the j

of

AT _ jf

jbest | | was | [ best | | was |„_.>p^ ,*^<^ ti mes is before was

ttne 1 \ \^LA so go to the left— ^ the is before wasLJILJ 50 g0 to the left

,Liilbest

I the | 1 the | times isafter the

"of I T | yf ^ so the BST has no nodessuccess! l ' having that key

Searching in a BST


insert times

Suppose that you want to insert a new node into a BST (in a symbol-tableimplementation, put a new key-value pair into the data structure). The logic issimilar to searchingfor a key, but the implementation is trickier.The keyto understanding it is to realizethat only one link must be changed to point to the new node,and that link is preciselythe link that would be found to be null in an unsuccessful

search for the key in that node.If the BSTis empty, we create and return

a new Node containing the key-value pair; ifthe search key is less than the key at the root,we set the left link to the result of inserting thekey-valuepair into the left subtree; if the searchkey is greater, we set the right link to the resultof inserting the key-value pair into the rightsubtree; otherwise, if the search key is equal,we overwrite the existing value with the newvalue. Resetting the link after the recursive callin this way is usually unnecessary, because thelink changes only if the subtree is empty, but itis as easy to set the link as it is to test to avoidsetting it.

BST (Program 4.4.3) is a symbol-tableimplementation based on these two recursivealgorithms. If you compare this code with ourbinary search implementation BinarySearch(Program 4.2.3) and our stack and queueimplementations Stack (Program 4.3.4) andQueue (Program 4.3.6), you will appreciate theelegance and simplicity of this code. Take thetime to think recursively and convince yourselfthat this code behaves as intended. Perhaps thesimplest way to do so is to trace the construction of an initiallyempty BSTfrom a sample set

of keys. Your abilityto do so is a sure test of your understanding of this fundamental data structure.

Moreover, the put() and get() methods in BST are remarkably efficient:typically, each accesses a small number of the nodes in the BST (those on the path

I best

it

of-jf

the

times is afteritsogo to the right

]times is be/orewas

sogo to the left

times is after theso it goeson the right

Insertinga new node into a BST

4.4 Symbol Tables

mm

Hi

•::-''}.'-^-i%U^

Program 4.4.3 BST symbol table

public class BST<Key extends Comparable<Key>, Value>{

private Node root;

private class Node{

Key key;Value val;Node left, right;Node(Key key, Value val){ this.key = key; this.val = val;

}

public Value get(Key key){ return get(root, key); }

private Value get(Node x, Key key){

if (x == null) return null;int cmp = key.compareTo(x.key);if (cmp < 0) return get(x.left, key);else if (cmp > 0) return get(x.right, key);else return x.val;

}

public boolean contains(Key key){ return (get(key) != null); }

public void put(Key key, Value val){ root = put(root, key, val); }

private Node put(Node x, Key key, Value val){

if (x == null) return new Node(key, val);int cmp = key.compareTo(x.key);if (cmp < 0) x.left = put(x.left, key, val);else if (cmp > 0) x.right = put(x.right, key, val);else x.val = val;return x;

}

Thisimplementation of thesymbol-table data type is centered on therecursive BSTdata structureand recursive methods for traversing it.

625

626

keyinserted

^the | it |

best I it I

best

the

of fit

best

CZD

times it

Constructing a BST


from the root to the node sought or to the null link thatis replaced by a link to the new node). Next, we showthat put operations and get requests take logarithmictime (under certain assumptions). Also, put() onlycreates one new Node and adds one new link. If youmake a drawing of a BSTbuilt by inserting some keysinto an initially empty tree, you certainly will be convinced of this fact—you can just draw each new nodesomewhere at the bottom of the tree.

Performance characteristics of BSTs The run

ning times of BSTalgorithms are ultimately dependenton the shape of the trees, and the shape of the trees isdependent on the order in which the keysare inserted.Understanding this dependence is a critical factor in being able to use BSTs effectively in practical situations.

Best case. In the best case, the tree is perfectly balanced (each Node has exactly two non-null children),with lgN nodes between the root and each leaf node. Insuch a tree, it is easyto see that the cost ofan unsuccessful search is logarithmic, because that cost satisfies thesame recurrence relation as the cost of binary search(see Section 4.2) so that the cost of every put operation and get request is proportional to lg JV or less.Youwould haveto be quite lucky to get a perfectlybalancedtree like this by inserting keys one by one in practice,but it is worthwhile to know the best possible performance characteristics.

Average case. If we insert random keys, we mightexpect the search times to be logarithmic as well, because the first element becomes the root of the tree and

should divide the keys roughly in half. Applying thesame argument to the subtrees, we expect to get aboutthe same result as for the best case. This intuition is in-

4.4 Symbol Tables

worst|

Bestcase(perfectly balanced) BSTs

deed validated by carefulanalysis: a classic mathematical derivation shows that thetime required for put and get in a tree constructed from randomly ordered keys islogarithmic (see the booksite for references). More precisely, the expected numberofkeycomparisons is ~2 In Nfor a random put orget in a keybuiltfrom N randomlyordered keys. In a practical application such as Lookup, when we can explicitly randomize the order of the keys, this result suffices to (probabilistically) guaranteelogarithmic performance. Indeed, since 2 In JV is about 1.39lg JV, the average caseis only about 39% higher than the bestcase. In an applicationlike Index, where wehave no control of the order of insertion, there is no guarantee, but typical datagiveslogarithmic performance (seeExercise 4.4.17).As with binary search, this factis very significant because of the enormousness of the logarithmic-linear chasm:with a BST-basedsymbol table implementation, we can perform millions ofoperations per second (or more), even in a huge table.

rofi

Typical BSTs constructedfrom randomly ordered keys

627


1 best 1

ADI I\ ,

[ of

A ,the

A|times|

\was |

\ .|worst|

Iworstl

Vwas |

/1ti mes

, '•the

'•r of

r±r^UiJ

, ',| best |

| best

worst|

1 ^ r

| was |

~s>~

c of |-^<

1timesi|7

1 the |

Worst case. In the worst case, each node has exactlyone null link,so the BST is likea linked list with an extra wasted link, whereputoperations and get requests take linear time. Unfortunately, thisworst case is not rare in practice—it arises, for example, when weinsert the keysin order.

Thus, good performance of the basic BSTimplementation isdependent on the keys being sufficientlysimilar to random keysthat the tree is not likely to contain many long paths. If you arenot sure that assumption is justified,do notusea simple BST. Youronly clue that something is amisswillbe slowresponse time as theproblem size increases. (Note: It is not unusual to encounter software of this sort!) Remarkably, there are BSTvariants that eliminate this worst case and guarantee logarithmic performance peroperation, bymakingalltrees nearlyperfectlybalanced.One popular variant is known as a red-black tree. The Java library Java,uti 1 .TreeMapimplements a symbol table using this approach.

Traversing a BST Perhaps the most basic tree-processingfunction isknown as tree traversal: givena (reference to) a tree, wewant to systematically processeverykey-valuepair in the tree. Forlinked lists, we accomplish this task by following the single linkto move from one node to the next. For trees, however, we havedecisionsto make,becausethere are generally two links to follow.Recursion comes immediately to the rescue. To process every keyin a BST:

Processeverykey-valuepair in the left subtree.Process the key-valuepair at the root.Process everykey-value pair in the right subtree.

This approach is known as inorder tree traversal, to distinguish itfrom preorder (do the root first) and postorder (do the root last),which arise in other applications. Given a BST, it is easy to convince yourself with mathematical induction that not only doesthis approach process every key pair in the BST, but that it processes them in key-sorted order. For example, the following method prints the keys in the tree rooted at its argument in key-sorted

Worst-case BSTs order:


private static void traverse(Node x){

if (x == null) return;traverse(x.left);StdOut.pri ntln(x.key);traverse(x.right);

}

This remarkably simple method is worthyof careful study. It can be used as a basis for a toSt ri ng()implementation for BSTs (see Exercise4.4.11) andalso a starting point for developing the iteratorthat we need to provide clients the ability to usea foreach loop to process the entries in key-sortedorder.

smallerkeys, in order key larger keys, in order

^ all keys,in order

Recursive inorder traversal of a binary search tree

Implementing an iterable symbol table. Aclose lookat the recursive t raverse ()method just considered leads to a way to make our BST data type Iterable. Forsimplicity, we just process the keys because we can get the values when we needthem. Our goalis to enableclientcodelikethe following:

BST<String, Double> st = new BST<String, Double>();

for (String key: st)StdOut.println(key + " + st.get(key));

Index (Program 4.4.2) is another example of such clientcode.As usual, we first promise to provide an iteratorO method by adding the

phrase implements Iterable<Key> to the class declaration. This addition is acommitment to provide an iteratorO method for iterating through the keys inthe table,in key-sorted order.Asusual, the i terator () method itselfis simple:

public Iterator<Key> iteratorO

{ return new BSTIterator(); }

We need a private nested class that implements the Iterator interface, but implementing such a class is a bit of a challenge. We cannot direcdy use recursivetraversal, becausewe need to be able to pause and restart the process. To this end,we maintain an explicit Stack that contains the sequence of nodes from the root


down to the current node.The system call stackduring the execution of the recursive traverseO has essentially this same information.

private class BSTIterator implements Iterator<Key>{

Stack<Node> stack = new Stack<Node>();

}

BSTIteratorO// see below

public boolean hasNextO{ return !stack.isEmptyO; }

public Key next()// see below


To complete this implementation, weneeda BSTIte rato r () constructorthat initializesthe stack and a next () method that returns the next key. The recursive t ra-verseO method calls itself for the left link of each node until reaching a null link(at the node with the smallestkeyin the BST). Therefore,to prepare for processingthe smallest key, we need to initialize the stack to contain the nodes in the BSTreached by following leftlinksfrom the root. To do so,weuse a helpermethod:

private void pushl_eft(Node x){

while (x != null)

{stack.push(x);x = x.left;

}}

BSTIteratorO{ pushLeft(root); }

In particular, the node with the smallest key in the BST is on the top of the stackafter this initialization. Now, to process a key, we pop the top node from the stackand process its right subtree using the same method:


public Key next(){

Node x = stack.pop();pushLeft(x.right);return x.key;

}

Convincingyourself that these methods allow clientslike Index to iterate throughthe keys of a BST in keyorder by tracing their operation on some sample trees willteach you a great deal about BSTs, stacks, and recursion.

Extended symbol table operations Theflexibility of BSTs enables the implementation of many usefuladditionaloperationsbeyondthose dictatedby the symbol tableAPI. We leave implementations of theseoperationsfor exercises and leavefurther study of their performance characteristics and applications for a course inalgorithms and data structures.

Minimum and maximum. To find the smallest key in a BST, follow left linksfrom the root until reaching null. The last keyencountered is the smallest in theBST. The same procedure following right linkslead to the largestkey.

Size. To keep trackof the numberof nodes in a BST, keep an extrainstance variable N in BST that counts the number of nodes in the tree. Initialize it to 0 and

increment it whenever creating a new Node. Alternatively, keep an extra instancevariable N in Node that counts the number of nodes in the subtree rooted at that

node. Initialize it to 1 and increment it for each node on the search path when inserting a new Node, taking care to handle properly the duplicate-keycase,when nonew Node is added (see Exercise 4.4.20).

Remove. Manyapplications demand the ability to remove a key-value pair with agivenkey. You can find explicitcode for removinga node from a BST on the book-siteor in a book on algorithms and data structures. Aneasy, lazywayto implementremove () relieson the fact that our symbol tableAPI disallows nul 1 values:

public void remove(Key key){

if (contains(key))put(key, null);

}


This approach necessitates periodically cleaning out nodes in the BST with nullvalues, becauseperformance willdegradeunless the sizeof the data structure staysproportional to the number of key-value pairs in the table.

Range search. With a recursive methodlike traverse(), wecan count the number of keys that fall between two given values or return an iterator for keys falling between two given values. For example, a financial institution might build asymbol-tablewhosekeys are accountbalances to be ableto processaccountswhosebalances are above certain limits.

Order statistics. If we maintain an instancevariablein each node having the sizeof the subtree rooted at each node, we can implement a recursive method that returns the fcth largestkeyin the BST in logarithmic time.

This list is representative; numerous other important operations havebeen invented for BSTs that are broadly useful in applications.

Henceforth, we will use the reference implementation ST that implements ourbasic interface using the symbol-table implementation in Java.uti 1 .TreeMap,which is based on advanced type of BST known as the red-black tree. Red-blacktrees, which you are likely to encounter if you take an advanced course in datastructures and algorithms, are of interest because they support a logarithmic-timeguaranteefor get(), put(), and manyof the other operations just described.

Set data type Asa final example, we consider a data type that is simpler than asymboltable,stillbroadlyuseful, and easyto implement with BSTs. Asetis a collection of distinct keys, likea symboltablewith no values. Wecould use ST and ignorethe values,but client code that uses the followingAPI is simpler and clearer:

public class SET<Key extends Comparable<Key»

SET() create a set

boolean isEmptyO is thesetempty?

void add (Key key) add key to theset

bool ean contai ns (Key key) is key in theset?

Note: Implementations shouldalso implement theIterabl e<Key> interface to enableclientsto access keys in sortedorder withforeach loops

APIfor a generic set

4.4 Symbol Tables

PI

h&ftfo ' t&^fi&fi^^mm

Program 4AA Dedupfilter

public class DeDup{

public static void main(String[] args){ // Filter out duplicate strings.

SET<String> distinct = new SET<String>();while (!Stdln.isEmptyO){ // Read a string, ignore if duplicate.

String key = Stdln. readStringO ;if (!distinct.contains(key)){ // Save and print new string,

distinct.add(key);StdOut.pri nt(key);

}StdOut.println();

>>

>

di sti net

key

633

set of distinctstringvalues in Stdln

This SET client isafilter that removes duplicate strings in the input stream, using a SET containing thedistinct strings encountered sofar.

% Java DeDup < TaleOfTwoCities.txtit was the best of times worst age wisdom foolishness.

Aswith symbol tables, there is no intrinsic reason that the keytype should implement the Comparable interface. However, processing Comparable items is typical,and we can take advantage of item comparison to develop efficient implementations, so we include Comparable in the interface. Implementing SET by deletingreferencesto val in our BST code is a straightforward exercise (seeExercise 4.4.15).

DeDup (Program 4.4.4) is a SET client that reads a sequence of strings fromstandard input and prints out the first occurrenceof eachstring (thereby removingduplicates). Youcan find many other examplesof SET clients in the exercises at theend of this section. In the next section, you will see the importance of identifyingsuch a fundamental abstraction, illustrated in the context of a case study.


Perspective The use of binary search trees to implement symbol tables andsets is a sterling example of exploiting the tree abstraction, which is ubiquitousand familiar. Trees lie at the basis of many scientific topics, and are widely usedin computer science. We are accustomed to many tree structures in everyday life,including family trees, sports tournaments, the organization chart of a company,and parse trees in grammar. Trees also arise in numerous computational applications, including function call trees, parse trees for programming languages, andfile systems. Many important applications are rooted in science and engineering,including phylogenetic trees in computational biology, multidimensional trees incomputergraphics, minimaxgame treesin economics, and quad treesin moleculardynamics simulations. Other,morecomplicated, linkedstructurescanbe exploitedas well, as you will see in Section 4.5.

Symbol table implementations are a prime topic of further study in algorithms and data structures. Examples include balanced BSTs, hashing, and tries.Implementations of many of these algorithms and data structures are found inJava and most other computational environments. DifferentAPIsand different assumptionsabout keys callfor different implementations. Researchers in algorithmsand data structures still study symbol-table implementations of all sorts.

People use dictionaries, indexes, and other kinds of symbol tables everyday.Within a short amount of time, applicationsbased on symbol tables will completely replace phone books,encyclopedias, and allsorts of physical artifacts that servedus well in the last millennium. Without symbol-table implementations based ondata structures such as BSTs, such applicationswould not be feasible; with them, wehavethe feeling that anything that weneed is instantly accessible online.

4.4 Symbol Tables

Q. Why use immutable symbol tablekeys?

A. If we changed a key while it was in the BST, it would invalidate the orderingrestriction.

Q. Whynot usethe Java librarymethods for symbol tables?

A. Now that you understand how a symbol table works, you are certainly welcome to use the industrial-strength versions j ava. uti 1. TreeMap and Java. uti 1.HashMap. They follow the samebasicAPI as BST, but they allow null keys and usethe names contai nsKeyO andkeySetO instead of contai ns() and iteratorO,respectively. They also contain additional methods such as remove (), but they donot provide any efficientway to add some of the additional methods that we mentioned, such as order statistics. You can also use Java.uti 1 .TreeSet and Java,uti 1. HashSet, which implement an API like our SET.

635


4.4.1 ModifyLookup to to makeaprogram LookupAndPut that allows put operations to bespecified on standardinput.Use the convention that aplus signindicatesthat the next two strings typed are the key-value pair to be inserted.

4.4.2 Modify Lookup to make a programLookupMul ti pi e that handlesmultiplevalues having the samekeybyputting the values on a queue,as in Index, and thenprinting them all out on a getrequest, as follows:

% Java LookupMultipie ami no.csv 3 0Leucine

TTA TTG CTT CTC CTA CTG

4.4.3 ModifyIndex to make a program IndexByKeyword that takesa file namefrom the command line and makes an index from standard input using only thekeywords in that file. Note: Using the samefile for indexing and keywords shouldgivethe same result as Index.

4.4.4 Modify Index to make a program IndexLines that considers only consecutive sequences of letters as keys (no punctuation or numbers) and uses linenumbers instead of word position as the value.This functionality is useful for programs, as follows:

% Java IndexLines 6 0 < Index.Javacontinue 12

enqueue 15Integer 4 5 7 8 14parselnt 4 5println 22

4.4.5 Develop an implementation Bi narySearchST of the symbol-tableAPIthatmaintains parallelarrays of keys and values, keepingthem in key-sorted order. Usebinary search for get, and move larger elements to the right one position for put(use array doubling to keepthe arraysizeproportional to the number of key-valuepairs in the table).Test your implementation with Index, and validate the hypothesis that using such an implementation for Index takes time proportional to theproduct of the number of strings and the number of distinct strings in the input.

4.4 Symbol Tables

4.4.6 Develop an implementation LinkedListST of the symbol-table API thatmaintains a linked list of nodes containing keysand values,keeping them in arbitrary order. Testyour implementation with Index, and validate the hypothesis thatusing such an implementation for Index takes time proportional to the product ofthe number of strings and the number of distinct strings in the input.

4.4.7 Draw all the different BSTs that can represent the keysequence best of i tthe time was.

4.4.8 Draw the BST that results when you insert items with keys

EASYQUESTION

in that order into an initially empty tree.

4.4.9 Suppose we have integer keys between 1 and 1000 in a BSTand search for363.Which of the following cannot be the sequence of keysexamined?

a. 2 252 401 398 330 363

b. 399 387 219 266 382 381 278 363

c. 3 923 220 911 244 898 258 362 363

d. 4 924 278 347 621 299 392 358 363

e. 5 925 202 910 245 363

4.4.10 Suppose that the following 31 keys appear (in some order) in a BST ofheight 5:

10 15 18 21 23 24 30 30 38 41 42 45 50 55 59

60 61 63 71 77 78 83 84 85 86 88 91 92 93 94 98

Draw the top three nodes of the tree (the root and its two children).

4.4.11 Implement toSt ri ng() for BST, using a recursivehelper method like t rave rse(). As usual, you can accept quadratic performance because of the cost ofstring concatenation. Extra credit: Write a linear-time toSt ri ng() method for BSTthat uses St ri ngBui 1der.

637


4.4.12 True or false: Givena BST, let x be a leaf node, and let p be its parent. Theneither (i) the key of p is the smallestkey in the BST larger than the key of x or (ii)the key of p is the largest key in the BST smaller than the key ofx.

4.4.13 Modify BST to add a method remove () that takes a key argument andremoves that key (and the corresponding value) from the symbol table, if it exists.Implement it by setting the value associatedwith the given key to null.

4.4.14 Modify the symbol-table API to handle values with duplicate keysby having get() return an iterator for the values having a given key. Implement BST andIndex as dictated by this API.Discussthe pros and cons of this approach versus theone given in the text.

4.4.15 Modify BST to implement the SET API given at the end of this section.

4.4.16 A concordance is an alphabeticallist of the words in a text that gives allwordpositions where each word appears. Thus, Java Index 0 0 produces a concordance. In a famous incident, one group of researchers tried to establish credibilitywhile keeping details of the Dead SeaScrolls secret from others by making publica concordance. Write a program InvertConcordance that takes a command-lineargument N, reads a concordance from standard input, and prints the first Nwordsof the corresponding text on standard output.

4.4.17 Run experiments to validate the claims in the text that the put operationsand get requests for Lookup and Index are logarithmic in the sizeof the table whenusing BST. Develop test clients that generate random keys and also run tests forvarious data sets, either from the booksite or of your own choosing.

4.4.18 Modify BST to add a method si ze() that returns the number of elementsin the table. Use the approach of storing within each Node the number of nodes inthe subtree rooted there.

4.4.19 Modify BST to add a method rangeCount () that takes two Key argumentsand returns the number of keysin a BST between the two givenkeys. Yourmethodshould take time proportional to the height of the tree. Hint: First work the previous exercise.

4.4 Symbol Tables

4.4.20 Modify BST to add methods mi n() and max() that return the smallest (orlargest) key in the table (or nul 1 if no such key exists).

4.4.21 Modify BST to implement a symbol-table APIwherekeys are arbitrary objects.Use hashCodeO to convert keys to integers and use integer keys in the BST.Note: This exercise is trickier than it might seem, because of the possibility thathashCodeO can return the same integer for two different objects.

4.4.22 Modify your SET implementation from Exercise 4.4.15 to add methodsf loor() and cei 1() that take as argument a Key and return the largest (smallest)element in the set that is no larger (no smaller) than the given Key.

4.4.23 Write an ST client that creates a symbol table mapping letter grades tonumerical scores, as in the table below,and then reads from standard input a list ofletter grades and computes their average (GPA).

A+ A A- B+ B B- C+ C C- D F

4.33 4.00 3.67 3.33 3.00 2.67 2.33 2.00 1.67 1.00 0.00


^mav%^^^a^icQes

This list of exercises is intended to give you experience in working with binary treesthat are notnecessarily BSTs. They all assume a Node class with three instance variables: a positive double value and two Node references. As with linked lists, you willfindit helpful tomake drawings using the visual representation shown in the text.

4.4.24 Implement the following methods that each take as argument a Node thatis the root of a binary tree.

int size()

int 1eaves()

double totalO

number of nodes in thetree

number of nodes whose links are both null

sumof thekeyvalues in all nodes

Your methods should all run in linear time.

4.4.25 Implement a linear-time method heightO that returns the maximumnumber of nodes on any path from the root to a leaf node (the height of the nulltree is 0; the height of a one-node tree is 1).

4.4.26 A binary tree is heap-ordered if the key at the root is larger than the keysin all of its descendants. Implement a linear-time method heapOrderedO that returns true if the tree is heap-ordered, and fal se otherwise.

4.4.27 Abinary tree is balanced if both its subtreesare balanced and the height ofits two subtrees differ by at most 1. Implement a linear-time method bal anced()that returns true if the tree is balanced, and fal se otherwise.

4.4.28 Two binary trees are isomorphic if only their key values differ (they havethe same shape). Implement a linear-time static method i somorphi c() that takestwo tree references as arguments and returns true if they refer to isomorphic trees,and fal se otherwise. Then, implement a linear-time static method eq () that takestwo tree references as arguments and returns true if they refer to identical trees(isomorphic with the same keyvalues),and fal se otherwise.

4.4.29 Implement a linear-time method i sBSTO that returns true if the tree is aBST, and fal se otherwise.

4.4 Symbol Tables

Solution: This task is a bit more difficult than it might seem. Use an overloadedrecursive method isBSTO that takes two additional arguments min and max andreturns true if the tree is a BST and all its values are between mi n and max.

public static boolean isBSTO{ return isBST(root, 0, Double.POSITIVE_INFINITY);

private boolean isBST(Node x, int min, int max){

if (x == null) return true;if (x.val <= min || x.val >= max) return false;if (!isBST(x.left, min, x.val)) return false;if (!isBST(x.right, x.val, max)) return false;

}

}

4.4.30 Write a method levelOrderO that prints BST keys in level order: firstprint the root, then the nodes one level belowthe root, left to right, then the nodestwo levels below the root (left to right), and so forth. Hint: Use a Queue<Node>.

4.4.31 Compute the value returned by mysteryO on some sample binary treesand then formulate a hypothesis about its behavior and prove it.

public int mystery(Node x){

if (x == null) return 0;return mystery(x.left) +

}

Answer: Returns 0 for any binary tree.

mystery(x.right);

641


Treatiy^^mmiiMs

4.4.32 Spell checking. Write a SET client Spell Checker that takes as command-line argument the name of a file containing a dictionary of words, and then readsstrings from standard input and prints out any string that is not in the dictionary.You can finda dictionaryfile on the booksite. Extra credit: Augment your programto handle common suffixes such as -ing or -ed.

4.4.33 Spell correction. Write an ST client Spell Corrector that serves as a filterthat replaces commonlymisspelled words on standard input with a suggested replacement, printingthe result to standard output.Take ascommand-line argumenta file that containscommon misspellings and corrections. You can find an exampleon the booksite.

4.4.34 Web filter. Write a SET client WebBlocker that takes as command-line argument the name of a file containing a list of objectionablewebsites,and then readsstrings from standard input and prints out only those websites not on the list.

4.4.35 Set operations. Add methods union() and intersection() to SET thateachtaketwosetsasarguments and return the union and intersection, respectively,of those two sets.

4.4.36 Frequency symbol table. Develop a data type FrequencyTable that supports the following operations: cl i ck() and count (), both of which take Stri ngarguments. The data-type value is an integer that keeps track of the number oftimes the cl i ck() operation has been called with the given Stri ng as argument.The click() operation increments the count by one, and the count () operationreturns the value, possibly 0. Clientsof this data type might include a web trafficanalyzer, a musicplayer that countsthe number of timeseachsonghasbeen played,phone softwarefor counting calls, and so forth.

4.4.37 ID range searching. Develop a data type that supports the following operations: insert a date, search for a date, and count the number of dates in the data

structure that lie in a particularinterval. Use Java's j ava. uti 1. Date data type.

4.4.38 Non-overlapping interval search. Given a list of non-overlapping intervalsof integers, write a function that takesan integer argument and determines inwhich, if any, interval that value lies. For example, if the intervals are 1643-2033,

4.4 Symbol Tables

5532-7643, 8999-10332, and 5666653-5669321, then the query point 9122 lies inthe third interval and 8122 lies in no interval.

4.4.39 IP lookup by country. Write a BST client that uses the data file ip-to-country. csv found on the booksite to determine from which country a given IPaddress is coming. The data file has five fields: beginningof IP addressrange,ending of IP address range, two-charactercountry code,three character country code,and country name. The IP addresses are non-overlapping.Sucha database tool canbe used for credit card fraud detection, spam filtering, auto-selection of languageon a website, and web server log analysis.

4.4.40 Inverted index of web. Given a list of web pages, create a symbol table ofwords contained in the web pages. Associate with eachword a list of web pages inwhich that word appears.Write a program that reads in a list of web pages,createsthe symboltable,and support single wordqueries byreturningthe listof webpagesin which that query word appears.

4.4.41 Inverted index of web. Extend the previous exercise so that it supportsmulti-word queries. In this case, output the list of web pages that contain at leastone occurrence of each of the query words.

4.4.42 Multiple word search. Write a program that takes k words from the command line, reads in a sequence of words from standard input, and identifies thesmallest interval of text that contains all of the k words (not necessarily in the sameorder). Youdo not need to consider partial words.

Hint: For each index i, find the smallest interval [i, j] that contains the k querywords. Keep a count of the number of times each of the k query words appear.Given [i,j], compute [x+1, j'] bydecrementing the counter forword i.Then, graduallyincrease;until the intervalcontains at leastone copyof eachof the kwords (or,equivalently, word i).

4.4.43 Repetition draw in chess. In the game of chess, if a board position is repeatedthree timeswith the samesideto move, the sideto move can declare a draw.Describe how you could test this condition using a computer program.

643


4.4.44 Registrar scheduling. TheRegistrar at a prominentnortheasternuniversityrecently scheduled an instructor to teach two different classes at the same exacttime. Help the Registrar preventfuture mistakes by describing a method to checkfor such conflicts. For simplicity, assumeall classes run for 50 minutes and start at9,10,11,1,2, or 3.

4.4.45 Entropy. Wedefinethe relative entropy of a text corpus with JV words,kofwhich are distinct as

E= 1/ (Nig JV) (p0 lg(*/p0) + Pl]g(k/Pl) + ... + pk_x \%{klpk_x))where p% is the fraction of times that word i appears. Write a programthat reads ina text corpus and prints out the relative entropy. Convert allletters to lowercase andtreat punctuation marks as whitespace.

4.4.46 Order statistics. Add to BST a method select() that takes an integer argument kand returns the kth largest keyin the BST. Maintain subtree sizes in eachnode (see Exercise 4.4.18). Therunning timeshould be proportional to the heightof the tree.

4.4.47 Rank query. Add to BST a method rank() that takes a key as argumentand returns the integer i suchthat keyis the ith largest element in the BST. Maintain subtree sizes in eachnode (see Exercise 4.4.18). The running time should beproportional to the height of the tree.

4.4.48 Delete ith element. Implement a class that supports the following API:

public class GeneralizedQueue<Item>

GeneralizedQueue()

boolean isEmptyO

void insert(Item item)

Item delete (int i)


is thequeueempty?

insert an item

delete andreturn the i th least recentlyinserted item

APIfor a generic generalized queue

4.4 Symbol Tables

Use a BST that associatesthe fcth element inserted with the key kand maintains ineach node the total number of nodes in the subtree rooted at that node. To find theith leastrecently addeditem,search for the ith smallest element in the BST.

4.4.49 Sparse vectors. AnN-dimensional vector issparse if itsnumber of nonzerovalues issmall. Your goal isto represent avector withspace proportional to itsnumber of nonzeros, and to be ableto add twosparse vectors in timeproportional to thetotal number of nonzeros. Implement a class that supports the following API:

public class SparseVector

SparseVector () create a vector

void put (int i, double v) set a; toy

double get (int i) return at

double dot (SparseVector b) vector dot product

SparseVector pi us (SparseVector b) vector addition

APIfor a sparse vector ofdouble values

4.4.50 Sparse matrices. An JV-by-JV matrixis sparse if its number of nonzeros isproportional to N (or less). Your goal is to represent a matrixwith space proportional to JV, and to be able to add and multiply two sparse matrices in time proportional to the total number of nonzeros (perhaps with an extra logN factor).Implement a class that supports the following API:

public class SparseMatrix

SparseMatri x() create a matrix

void put (int i, int j, double v) set aV) toydouble get (int i, int j) return a-^

SparseMatrix pi us (SparseMatrix b) matrix addition

SparseMatrix times (SparseMatrix b) matrix product

API for a sparse matrix ofdouble values

645


4.4.51 Queue with no duplicates. Create a data type that is a queue, except thatan element may only appear on the queue at most once at anygiven time. Ignorerequeststo insert an item if it is alreadyon the queue.

4.4.52 Mutable string. Create a data type that supports the following API on astring. Usea BST to implement alloperations in logarithmic time.

public class MutableString

MutableStringO

void get (int i)

void insert(int i, char c)

char delete(int i)

int lengthQ

create an emptystring

return the i thcharacter in thestring

insert c and make it the i th character

delete and return the i th character

return thelength of thestring

APIfora mutable string

4.4.53 Assignment statements. Write a program to parse and evaluate programsconsisting of assignmentand print statementswith fullyparenthesizedarithmeticexpressions (see Program4.3.5). For example, given the input

A = 5

B = 10

C = A + B

D = C * C

print(D)

your program should print the value 225.Assume that all variables and values areof type double. Use a symbol tableto keep track of variable names.

4.4.54 Random element. Addto your SET implementation from Exercise 4.4.15 amethod random () that returns a random key. Therunningtimeshould beproportional to the length of the path from the root to the node returned. Hint Add toNode an i nt instance variable si ze to contain the size of the subtree rooted at eachnode and update the rest of the code to maintain si ze.

4.4 Symbol Tables

4.4.55 Dynamic discrete distribution. Create a data type thatsupports the followingtwo operations: add() and random(). The add() method should inserta newitem into the data structure if it has not been seen before; otherwise, it should increase itsfrequency countbyone.The random() methodshouldreturn an elementat random,where the probabilities areweighted bythe frequency of each element.Usespaceproportional to the number of items.

4.4.56 Random phone numbers. Write a program that takes a command-line argumentJV and prints JV random phone numbersof the form (xxx) xxx-xxxx.Usea SET to avoid choosing the same numbermorethan once. Use onlylegal areacodes(youcan find a file of such codes on the booksite).

4.4.57 Codon usage table. Writea programthat uses a symbol table to print outsummarystatistics for each codon in a genome taken from standard input (frequency per thousand), like the following:

UUU 13.2 UCU 19.6 UAU 16.5 UGU 12.4

UUC 23.5 UCC 10.6 UAC 14.7 UGC 8.0

UUA 5.8 UCA 16.1 UM 0.7 UGA 0.3

UUG 17.6 UCC 11.8 UAG 0.2 UGG 9.5

CUU 21.2 ecu 10.4 CAU 13.3 CGU 10.5

CUC 13.5 CCC 4.9 CAC 8.2 CGC 4.2

CUA 6.5 CCA 41.0 CAA 24.9 CGA 10.7

CUC 10.7 CCG 10.1 CAG 11.4 CGG 3.7

AUU 27.1 ACU 25.6 AAU 27.2 AGU 11.9

AUC 23.3 ACC 13.3 AAC 21.0 AGC 6.8

AUA 5.9 ACA 17.1 AAA 32.7 AGA 14.2

AUC 22.3 ACG 9.2 AAG 23.9 AGG 2.8

GUU 25.7 GCU 24.2 GAU 49.4 GGU 11.8

GUC 15.3 GCC 12.6 GAC 22.1 GGC 7.0

GUA 8.7 GCA 16.8 GAA 39.8 GGA 47.2

4.4.58 Unique substrings of length L. Write a program that reads in text fromstandard input and calculates the number of uniquesubstrings of length Lthat itcontains. For example, if the input is cgcgggcgcg, then there are five unique substrings of length 3: cgc, egg, gcg, ggc, and ggg. This calculation is useful in datacompression. Hint: Use the string method substri ng(i, i + L) to extract the

647


i th substring and insert intoasymbol table. Test your program on alarge genomefrom the booksite andon the first 10 million digits of it.

4.4.59 Password checker. Write a program that reads in a string from the commandlineandadictionary of words from standard input,andchecks whether it isa"good" password. Here, assume "good" means thatit (i) isatleast eight characterslong, (ii) isnot aword in the dictionary, (Hi) is not aword in the dictionary followed by adigit 0-9 (e.g., hel1o5), (iv) isnot two words separated by adigit (e.g.,hello2world), and (v) none of (ii) through (iv) hold for reverses of words in thedictionary.


4.5 Case Studjt Small World

The mathematical model that we use for studying the nature of pairwise connections among entities is known as the graph. Graphs are important for studyingthe natural world and for helping us to better understand and refine the networksthat we create. From models of the ner

vous system in neurobiology, to thestudy 4.5.1 Graph data type 657of the spread of infectious diseases in 4.5.2 Using agraph toinvert anindex . .661medical science, to the development of 4-5*3 Shortest-paths client 665.he telephone system, graphs have played J£ ZSEZZfTT*?. \%a critical role in science and engineeringover the past century, including the de- Pn*rams'"this sectionvelopment of the internet itself.

Some graphs exhibit a specific property known as the small-world phenomenon. You may be familiar with this property, which is sometimes known as sixdegrees ofseparation. It is the basic ideathat, even though each of us has relativelyfew acquaintances, there is a relatively short chain of acquaintances (the six degrees of separation) separatingus from one another.This hypothesiswasvalidatedexperimentally by Stanley Milgram in the 1960s and modelled mathematically byDuncanWatts and Stephen Strogatz in the 1990s. In recentyears, the principlehasproven important in a remarkable variety of applications. Scientists are interestedin small-world graphs because they model natural phenomena, and engineers areinterested in building networks that take advantage of the natural properties ofsmall-world graphs.

In this section, we address basic computational questions surrounding thestudy of small-worldgraphs. Indeed, the simple question

Doesa given graph exhibit the small-worldphenomenon?

can present a significant computational burden. To address this question, we willconsider a graph-processing data type and several usefulgraph-processing clients.In particular,wewillexaminea clientfor computing shortestpaths^ a computationwhichhas a vastnumber of important applications in its own right.

A persistent theme of this section is that the algorithms and data structuresthat wehave beenstudying play a central role in graphprocessing. Indeed, youwillsee that several of the fundamental data types introduced earlier in this chapterhelp us to develop elegant and efficient code for studying the properties of graphs.

4.5 Small World Phenomenon

Graphs To nip in the bud any terminological confusion, we start right awaywith some definitions. A graph is comprised of a set of vertices and a set of edges.Each edge represents a connection between two vertices. Two verticesare neighbors if they are connected by an edge, and the degree of avertex is its number of neighbors. Note that there is no relationshipbetweena graph and the ideaof a function graph (a plot of a functionvalues) or the idea of graphics (drawings). We often visualizegraphsby drawing labelled geometric shapes (vertices) connected by lines(edges), but it is always important to remember that it is the connections that are essential,not the waywe depict them.

The following list suggests the diverse range of systems wheregraphs are appropriate starting points for understanding structure.

651

neighbors

\vertex

of degree 2

Graph terminology

Human biology. Arteries and veins connect organs, synapses connect neurons,and joints connect bones, so an understanding of the human biology depends onunderstanding appropriate graph models. Perhaps the largest and most importantsuch modelling challengein this arena is the human brain. How do local connections among neurons translate to consciousness, memory, and intelligence?

Social networks. Peoplehave relationshipswith other people. From the study ofinfectious diseases to the study of politicaltrends, graph models of these relation-

vertices edges

JFK JFK MCO

MCO ORD DEN

ATL ORD HOU

ORD DFW PHX

HOU JFK ATL

DFW ORD DFW

PHX ORD PHX

DEN ATL HOU

LAX DEN PHX

LAS PHX LAX

JFK ORD

DEN LAS

DFW HOU

ORD ATL

LAS LAX

ATL MCO

HOU MCO

LAS PHX

Graph modelof a transportation system

652

system vertex edge

naturalphenomena

circulatory organ blood vessel

skeletal joint bone

nervous neuron synapse

social person relationship

epidemiological person infection

chemical molecule bond

N-body particle force

genetic gene mutation

biochemical protein interaction

engineered systems

transportation airport route

intersection road

communication telephone wire

computer cable

web page link

distribution power station

home

reservoir

power line

homepipe

warehouse

retail outlettruck route

mechanical joint beam

software module call

financial account transaction

Typical graph models


ships are critical to our understanding of theirimplications. Hoesdoes information propagateinonline networks?

Physical systems. Atoms connect to form molecules, molecules connect to form a material ora crystal, and particles are connected by mutualforces such as gravityor magnetism.Graph models are appropriate for studying the percolationproblem that we considered in Section 2.4, theinteracting charges that we considered in Section3.1, and the N-body problem that we consideredin Section 3.4. How do local interactions propagatethrough such systems as they evolve?

Transportation systems. Train tracks connectstations, roads connect intersections, and airlineroutes connect airports, so all of these systemsnaturally admit a simple graph model. No doubtyou have used applications that are based on suchmodels when getting directions from an interactive mapping program or a GPS device, or using an online service to make travel reservations.What is the best wayto get from here to there?

Communicationssystems. Fromelectric circuits,to the telephone system,to the internet, to wirelessservices, communications systems are all based onthe ideaof connecting devices. Forat leastthe pastcentury, graph models have played a critical rolein the development of such systems.What is thebest way to connect the devices?

Resource distribution. Power lines connect

power stations and home electrical systems,pipesconnect reservoirs and home plumbing, and truck


vertices edges

aaa edu aaa.edu www.com

www com www.com fff.orgmmm net www.com mmm.net

fff org www.com ttt.gov

ttt gov www.com fff.orgwww.com mmm.net

mmm.net fff.orgfff.org aaa.edu

ttt.gov aaa.edu

ttt.gov mmm.net

Graph model of the web

routes connect warehouses and retail outlets. The study of effective and reliablemeans of distributing resources depends on accurategraph models.Where are thebottlenecks in a distribution system?

Mechanical systems. Trusses or steel beams connect jointsin a bridgeor a building. Graph models help us to designthesesystems and to understand their properties.What forces must a joint or a beam withstand?

Software systems. Methods in one program module invoke methods in othermodules. As we have seen throughout this book, understanding relationships ofthis sort is a key to success in software design. Which modules willbe affected by achange in an API?

Financialsystems. Transactionsconnectaccounts, and accountsconnect customers to financial institutions. These are but a few of the graph models that peopleuse to study complexfinancial transactions, and to profit from better understanding them. Which transactions are routine and whichare indicative of a significantevent that might translate to profits?

653


Some of these are models of natural phenomena,where our goal is to gainabetterunderstanding of the natural world by developing simple modelsand then usingthem to formulate hypothesesthatwe cantest.Other graphmodels are ofnetworksthat we engineer, where our goal is to build a better network or to better maintaina network by understanding its basiccharacteristics.

Graphs are useful models whether they are small or massive. A graph having just dozens of vertices and edges (for example, one modeling a chemical compound,where vertices are molecules andedges are bonds) is already acomplicatedcombinatorial objectbecause there are a huge number of possible graphs, so understanding the structures of the particular ones at hand is important. A graphhaving billions or trillions of vertices and edges (for example, a governmentdatabase containing all phone calls or a graph model of the human nervoussystem) isvastly morecomplex, and presents significant computational challenges.

Processing graphs typically involves buildinga graph from information in a database and thenanswering questions about the graph. Beyond theapplication-specific questions in the examples justcited, we often need to ask basic questions aboutgraphs. Howmanyvertices andedges doesthe graphhave? What are the neighbors of a given vertex?Some questions depend on an understanding of thestructure of a graph. For example,apaf/z in a graphis a sequence ofvertices connectedby edges. Is therea path connecting two given vertices? What is theshortest such path? What is the maximum length ofa shortest path in the graph (the graph's diameter)7.

We have already seen in this book several examples of questions from scientificapplications that are much more complicated than these. What is the probabilitythatarandom surfer willland on each vertex? What isthe probability thatasystemrepresentedby a certain graph percolates?

As you encounter complex systems in later courses, you are certain to encounter graphs in many different contexts. You may also study their properties indetail in later courses in mathematics, operations research, or computer science.Some graph-processing problems present insurmountable computational challenges; otherscanbe solved with relative ease with data-type implementationsofthe sort we havebeen considering.

a pathfromLAS to JFK

\

a shortest pathfrom LAX to MCO

Paths in a graph

4.5 Small World Phenomenon 655

Graph data type Graph-processing algorithms generallyfirst build an internalrepresentation of a graph by adding edges, then process it by iterating through theverticesand through the edgesthat are adjacentto a vertex. The following API supports such processing:

public class Graph

Graph () create anempty graph

Graph(In in, String delim) read graph from input stream

void addEdge(String v, String w) addedge v-w

int V() number of vertices

int E() number ofedges

Iterabl e<St ri ng> verti ces () vertices in thegraph

Iterabl e<String> adjacentTo(String v) neighbors of"v

int degree(String V) number ofneighbors ofv

boo! ean hasVertex(Stri ng v) isv a vertex in the graph?

boolean hasEdge(String v, String w) isv-wan edge in the graph?

APIfor a graph withStri ng vertices

As usual, this API reflects several design choices, each made from among variousalternatives, some of which we now briefly discuss.

Undirected graph. Edges are undirected: an edge that connects v to wis the sameas one that connects wto v. Our interest is in the connection, not the direction. Di

rectededges (forexample, one-way streets in road maps) requirea slightly differentdata type (see Exercise4.5.35).

String vertex type. We might use a generic vertex type, to allow clients to buildgraphs with objects of any type. We leave this sort of implementation for an exercise, however, because the resulting code becomes a bit unwieldy (see Exercise4.5.9).The Stri ng vertex type suffices for the applicationsthat we consider here.

Implicit vertex creation. When a String is used as an argument to addEdgeO,weassumethat it is a vertexname. If no edgeusingthat Stri nghasyet been added,our implementationcreates a vertex with that name.The alternative designof hav-


ing an addVertexO method requiresmore client code (to createthe vertices) andmore cumbersomeimplementationcode(to checkthat edges connectvertices thathave previouslybeen created).

Self-loops and parallel edges. Although the API does not explicidy address theissue, we assume that implementations doallow self-loops (edges connectingavertex to itself)but donotallow parallel edges (twocopies ofthe sameedge). Checkingfor self-loops and parallel edges is easy; our choiceis to omit both checks.

Client query methods. We also include the methods V() and E() in our API toprovide to the client the number of vertices and edges in the graph. Such methodsshould provide the requisite informationin constanttime. Similarly, the methodsdegreeO, hasVertexO, and hasEdge() are useful in client code. We leave as exercisesthe implementation of these methods, but assume them to be in our GraphAPI.

None of these design decisions are sacrosanct; they are simply the choices that wehave made for the code in this book. Some other choices might be appropriate invarioussituations, and some decisions are stillleft to implementations. It iswise tocarefully consider the choices that you make for design decisions like this andto bepreparedto defend them.

Graph (Program 4.5.1) implements this API. Itsinternalrepresentation is asymbol table ofsets: the keysare vertices and the values are the setsof neighbors—the vertices adjacent to the key. This representationuses the two data types STand SET that we introducedin Section 4.4. It has three important properties:

• Clients can efficientlyiterate through the graphvertices.

• Clientscanefficientlyiterate through avertex'sneighbors.

• Space usage is proportional to the number ofedges.

These properties follow immediatelyfrombasic properties of ST and SET. As you will see, the two iteratorsareat the heart of graph processing.

c

set ofneighbors

C G

A

(To)A C

A

symbolyS table

value

Symbol-table-of-setsgraph representation


mi

Program 4,5.1 Graph data type

public class Graph

{private ST<String, SET<String» st; st

public Graph() "^WH

{ st = new ST<String, SET<String»(); }

symbol tableofvertex neighbor sets

}

public void addEdge(String v, String w){ // Put v in w's SET and w in v's SET.

if (1st.contains(v)) st.put(v, new SET<String>0);if (1st.contains(w)) st.put(w, new SET<String>());st.get(v).add(w);st.get(w).add(v);

}

public Iterable<String> adjacentTo(String v){ return st.get(v); }

public Iterable<String> verticesO

{ return st; } mm// See exercise 4.5.1-4 for V(), E(), degreeO,// hasVertexQ, and hasEdge().

public static void main(String[] args){ // Read edges, print Graph (sets of neighbors).

Graph G = new Graph();while (!Stdln.isEmptyO)

G.addEdge(StdIn.readString(), Stdln.readString());StdOut.print(G);

}

adjacentToOverticesQ

neighbor iteratorvertex iterator

& Js^-^se^r™*^? is?P$l3?Hy»5

This implementation uses ST and SET (see Section 4.4) to implement the graph data type.Clients build graphs by adding edges and process them by iterating the vertex setand the setofvertices adjacent toagiven vertex. See the textfor toSt ri ng() anda matching constructor thatreads a graph from an inputstream.

% Java Graph < tiny.txtA B C G H

B A

CAG

GAC

H A

I


Asa simple exampleof client code,consider the problem of printing a Graph.A natural way to proceed is to print a list of the vertices, along with a list of immediate neighbors of each vertex.Weuse this approach to implement toSt ri ng()in Graph, as follows:


String s = "";for (String v : vertices()){

s += v + " ";for (String w : adjacentTo(v))

s += w -

s += "\n";

}

}return s;

This codeprints two representations of eachedge, oncewhen discovering that wisa neighbor of v and once when discovering that v is a neighbor of w. Manygraphalgorithms are based on this basicparadigmof processing each edge in the graphin this way, and it is important to remember that they processeach edge twice. Asusual, this implementationisintendedfor useonlyfor smallgraphs,as the runningtime is quadratic in the string length because string concatenation is linear-time.

The output format just considered defines a reasonable file format: each lineis a vertex name followed by the names of neighbors of that vertex. Accordingly,our basic graph API includes a constructor for building a graph from an inputstream in this format (list of vertices with neighbors). For flexibility, we allowforthe use of other delimiters besides spaces for vertex names (so that, for example,vertex names may contain spaces),as in the following implementation:

public Graph(In in, String delimiter){

st = new ST<String, SET<String»();while (Hn.isEmptyO){

String line = in.readLineO;String[] names = line.split(delimiter);for (int i = 1; i < names.length; i++)

addEdge(names[0], names[i]);}

}


Adding this constructor and toStri ng() to Graph provides a complete data typesuitable for a broad variety of applications, as we will now see.Note that this sameconstructor (with a space delimiter) works properly when the input is a list of edges, one per line, as in the test client for Program 4.5.1.

Graph diciat example As a first graph-processing client, we consider an example of social relationships, one that is certainly familiar to you and for whichextensive data is readily available.

On the booksite you can find the file movies.txt (and many similar files),which contains a list of movies and the performers who appeared in them. Eachline gives the name of a movie followed by the cast (a list of the names of the performers who appeared in that movie). Since names have spaces and commas inthem, the / character is used as a delimiter. (Now you can see why our file inputGraph constructor takes the delimiter as an argument.)

If you study movies.txt, you will notice a number of characteristics that,though minor, need attention when workingwith the database:

• Movies always have the year in parenthesesafter the title.• Special characters are present.• Multiple performers with the same name are differentiated by Roman

numerals within parentheses.• Cast lists are not in alphabetical order.

Depending on your terminal and operating systemsettings,specialcharacters maybe replacedby blanks or question marks.Thesetypes of anomalies are common inworking with large amounts of real-world data. We can either choose to livewiththem or write filters to minimize any annoyances.

% more movies.txt

Tin Men (1987)/DeBoy, David/Blumenfeld, Alan/... /Geppi, Cindy/Hershey, BarbaraTirez sur le pianiste (1960)/Heymann, Claude/.../Berger, Nicole (I)Titanic (1997)/Mazin, Stan/...DiCaprio, Leonardo/.../Winslet, Kate/...Titus (1999)/Weisskopf, Hermann/Rhys, Matthew/.../McEwan, GeraldineTo Be or Not to Be (1942)/Verebes, Erno (I)/.../Lombard, Carole (I)To Be or Not to Be (1983)/.../Brooks, Mel (I)/.../Bancroft, Anne/...To Catch a Thief (1955)/Paris, Manuel/.../Grant, Cary/.../Kelly, Grace/...To Die For (1995)/Smith, Kurtwood/.../Kidman, Nicole/.../ Tucci, Maria

Movie database example


_L_ Caligola

_Y Patrick A I nial M I f Grace \-\ Allen ) for Murder V Ke11V J

—• Enigma

Eternal Sunshine

of the Spotless —Mind

i—r

( Serretta A__^ Wilson J

Titanic P -f AYves \ \ I *^T~X

> r"\

A tinyportion of the movie-performer relationship graph

UsingGraph, we can write a simple and convenientclient for extracting information from movi es. txt. We beginby building a Graph to better structure theinformation. What should the vertices and edges model? Should the vertices bemovies with edges connecting two movies if a performer has appeared in both?Should the vertices be performers with edges connecting two performers if bothhave appeared in the same movie? These choices are both plausible, but whichshould we use? This decisionaffects both clientand implementation code.Anotherwayto proceed (whichwe choosebecauseit leads to simple implementation code)isto have vertices for both the movies and the performers, withan edge connectingeach movie to each performer in that movie. As youwill see, programs that processthis graph can answera greatvarietyof interestingquestions.The Graph client In-dexGraph (Program 4.5.2) is a first example that takesa query,such as the name ofa movie,and prints the list of performers that appear in that movie.


w^^^^^^^^^i^^^^m^^^mmmm^mmmms

Program 4.5.2 Usinga graph to invert an index

public class IndexGraph{

public static void main(String[] args){ // Build a graph and process queries.

In in = new In(args[0]);String delimiter = args[l];Graph G = new Graph(in, delimiter);while (!Stdln.isEmptyO){ // Read a vertex and print its neighbors.

String v = Stdln.readLine();for (String w : G.adjacentTo(v))

StdOut.println(" " + w);}

}}

in

delimiter

G

v

w

input streaminputdelimitergraphquery

neighbor of v

This Graphclient builds agraph, then accepts vertex namesfrom standard inputandprints itsneighbors. When thefile isan index, it creates a bipartite graph andamounts toan interactiveinverted index.

'tP'-'fii'M-JA W$M4 -iWW.M.Ifwm.rfu ,--T- iM - u* V„..,r.

% Java IndexGraph tiny.txt " "c

A

A

G

B

C

G

H

mm:

% Java IndexGraph movies.txt "/"Da Vinci Code, The (2006)Aubert, Yves

Herbert, Paul

Wilson, SerrettaZaza, Shane

Bacon, KevinAnimal House (1978)Apollo 13 (1995)

Wild Things (1998)River Wild, The (1994)Woodsman, The (2004)

''IQffinfflPMSIVPMPi


Typinga movie name and getting its cast is not much more than regurgitating thecorresponding line in movies.txt (though the IndexGraph test client does printthe cast list sorted by last name, as that is the default iteration order provided bySET). A more interesting feature of IndexGraph is that you can type the name of aperformer and get the list of movies in which that performer has appeared. Whydoes this work? Even though the databaseseems to connect movies to performersand not the other wayaround, the edgesin the graph are connections that also connect performers to movies.

A graph in which connections all connect one kind of vertex to another kindof vertex is known as a bipartite graph. Asthis example illustrates, bipartite graphshavemany natural properties that we can often exploit in interesting ways.

As we saw at the beginning of Section 4.4, theindexing paradigm is general and very familiar. It isworth reflecting on the fact that building a bipartitegraph provides a simple way to automatically invertany index! The movi es. txt database is indexed bymovie, but we can query it by performer. Youcoulduse IndexGraph in precisely the same way to printthe index words appearing on a given page or thecodons corresponding to a given amino acid, or toinvert any of the other indices discussed at the beginning of Section 4.2. Since IndexGraph takes thedelimiter as a command-line argument, you can useit to create an interactive inverted index for a . csv

file or a test filewith space delimiters.This inverted-index functionality is a direct

benefit of the graph datastructure. Next,we examinesome of the added benefits to be derived from algorithms that process the data structure.

% more ami no.csv

TTT,Phe,F,Phenylalani neTTC,Phe,F,Phenylalani neTTA,Leu,L,LeucineTTG,Leu,L,LeucineTCT,Ser,S,SerineTCC,Ser,S,SerineTCA,Ser,S,SerineTCG,Ser,S,SerineTAT,Tyr,Y,Tyrosine

GGA,Gly,G,GlycineGGG,Gly,G,Glycine

% java IndexGraph amino.csv ", *TTA

Lue

L

Leucine

Serine

TCT

TCC

TCA

TCG

Inverting an index


Shortest paths in graphs Given two vertices in a graph, a path is a sequenceof edgesconnecting them. A shortestpathis one with minimal length over all suchpaths (there typicallyare multiple shortest paths). Findinga shortest path connecting two vertices in a graph is a fundamental problem in computer science.Shortestpaths have been famously and successfully applied to solve large-scale problemsin a broad variety of applications, from routing the internet to financial arbitragetransactions to studying the dynamics of neurons in the brain.

As an example, imagine that you are a customer of an imaginary no-frillsairline that serves a limited number of cities with a limited number of routes. As

sume that best wayto get from one placeto another is to minimizeyour number offlight segments,becausedelays in transferring from one flight to another are likelyto be lengthy(or perhaps the best thing to do is to considerpayingmore for a directflight on another airline!). A shortest-pathalgorithmis just what you need to plana trip. Suchan application appealsto intuition in understanding the basic problemand our approach to solving it. After covering these topics in the context of thisexample,we will consider an application where the graph model is more abstract.

Depending upon the application, clients have various needs with regard toshortest paths. Do we want the shortest path connecting two given vertices? Justthe length of such a path?Willwe havea largenumber of such queries? Is one particular vertex of interest? In huge graphs or for huge numbers of queries, we haveto pay particular attention to such questions because the cost of computing pathsmight prove to be prohibitive.Westart with the following API:

public class PathFinder

PathFinder(Graph G, String s) constructor

int distanceToCString v) length ofshortestpath3 from stov inC

Iterabl e<String> pathTo(String v) shortest path* K * from stov inG

APIfor single-source shortestpaths in a Graph

Clients can construct a PathFi nder for a givengraph and a givenvertex, and thenusethe PathFi nder either to find the length of the shortest path or to iterate throughthe vertices on the shortest path to any other vertex in the graph. An implementation of these methods is known as a single-source shortest-path algorithm. A classicalgorithm known as breadth-first search provides a direct and elegant solution.


Single-source client. Suppose that you have available to you the graph of verticesand connections for your no-frills airline'sroute map. Then, using your home cityas a source,you can write a client that prints your route any time you want to go ona trip. Program 4.5.3 is a client for PathFi nder that provides this functionality forany graph. This sort of client is particularly useful in applications where we anticipate numerous queries from the same source. In this situation, the cost of buildinga PathFi nder is amortized over the cost of all the queries. You are encouraged toexplore the properties of shortest paths by running PathFinder on our sampleinput routes. txt or any input model that you choose. The exercisesat the end of

this section describe several mod

els that you might consider.

Degrees of separation. One ofthe classicapplications of shortest-paths algorithms is to find the degrees of separation of individualsin social networks. To fix ideas, we

discuss this application in termsof a recently popularized pastimeknown as the Kevin Bacon game,which uses the movie-performergraph that we just considered.Kevin Bacon is a prolific actor whohas appeared in many movies. Weassign every performer who hasappeared in a movie a Kevin Baconnumber: Bacon himself is 0, any

performer who has been in the same cast as Bacon has a Kevin Bacon number of 1,any other performer (except Bacon) who has been in the same cast as a performerwhose number is 1 has a Kevin Bacon number of 2, and so forth. For example,Meryl Streep has a Kevin Bacon number of 1 because she appeared in TheRiverWild with Kevin Bacon. Nicole Kidman's number is 2: although she did not appearin any movie with Kevin Bacon, she was in Cold Mountainwith Donald Sutherland,and Sutherland appeared in AnimalHouse with Kevin Bacon. Given the name ofa performer, the simplest version of the game is to find some alternating sequenceof movies and performers that lead back to Kevin Bacon. For example, a movie

source destination distance shortestpaths

DFK LAX 3

LAS MCO 4

HOU DFK 2

JFK-0RD-PHX-LAX

LAS-PHX-DFW-H0U-MC0 andfourothers

HOU-ATL-DFK and two others

Examples ofshortest pathsin a graph


i

Program 4.5.3 Shortest-paths client

public class PathFinder{

// See Program 4.5.5 for implementation.

}

public static void main(String[] args){ // Read a graph and process queries

// for shortest paths from s.In in = new In(args[0]);String delimiter = args[l];Graph G = new Graph(in, delimiter);String s = args[2];PathFinder pf = new PathFinder(G, s);while (!Stdln.isEmptyO){ // Print distance and shortest path from s to input t

String t = Stdln.readLine();int d = pf.distanceTo(t);for (String v : pf.pathTo(t))

StdOut.println(M " + v);StdOut.println("distance " + d);

}y

in

delimiter

G

s

pft

V

input streaminputdelimitergraphsource

PathFi nder from sdestination queryvertex on path

This PathFi nder test client takes afile name, a delimiter, anda source vertex ascommand-linearguments. It builds a graph from thefile, assuming thateach line of thefile specifies a vertexanda listof vertices connected to thatvertex, separated bythe delimiter. When you type a destination on standard input, youget the shortest path from the source to thatdestination.

'^""""" ""ferial '"'"' ;":'^;^^-^^j^-'i:^^^j!-''i:--' ^"ife% more routes.txt

jfk mco

ORD DEN

ORD HOU

DFW PHX

JFK ATL

ORD DFW

ORD PHX

ATL HOU

DEN PHX

PHX LAX

JFK ORD

DEN LAS

DFW HOU

ORD ATL

LAS LAX

ATL MCO

HOU MCO

LAS PHX

% Java PathFinder routes.txt " " JFKLAX

JFK

ORD

PHX

LAX

distance 3

MCO

JFK

MCO

distance 1

DFW

JFK

ORD

DFW

distance 2


buff mightknowthat TomHankswas in Joe Versus the Volcano with Lloyd Bridges,who was in High Noon with Grace Kelly, who was in Dial Mfor Murder with Patrick Allen, who was in The Eagle Has Landed with Donald Sutherland, who weknow was in Animal House with Kevin Bacon.But this knowledge does not sufficeto establish Tom Hanks's Bacon number (it is actually 1 because he was in Apollo

13 with Kevin Bacon). You can see

%java PathFinder movies.txt "/" "Bacon, Kevin" that the Kevin Bacon number has toKidman, Nicole be defined by counting the movies in

Bacon, Kevin theshortest such sequence, soit ishardAnimal House (1978) ^ .Sutherland, Donald (I) to be sure whether someone wins theCold Mountain (2003) game without using a computer. Re-

distlnce^ NlC°1e markably, the PathFinder test clientHanks, Tom in Program 4.5.3 is just the program

Bacon, Kevin vou nee(j to f^ a shortest path thatApollo 13 (1995) ii. i , „ • ™ i_Hanks Tom establishes the Kevin Bacon number

distance 2 of any performer in movi es. txt—thenumber is precisely half the distance.

Degrees ofseparation from Kevin Bacon „ . ,. ,i .6 J r J You might enjoy using this program,

or extending it to answer some entertaining questions about the moviebusiness or in one of many other domains. Forexample, mathematicians play this same game with the graph defined by paperco-authorship and their connection to Paul Erdos, a prolific 20th-century mathematician. Similarly, everyone in New Jersey seems to have a Bruce Springsteennumber of 2, because everyone in the state seemsto know someone who claims toknow Bruce.

Otherclients. PathFi nder is a versatile data type that can be put to many practical uses. For example, it is easy to develop a client that handles pairwise source-destination requests on standard input, by building a PathFi nder for each vertex(see Exercise 4.5.17).Travel services use preciselythis approach to handle requestsat a very high service rate. Since this client builds a PathFinder for each vertex(each of which might consume space proportional to the number of vertices),spaceusagemight be a limitingfactor in usingit for huge graphs.For an evenmoreperformance-criticalapplicationthat isconceptuallythe same,consider an internetrouter that has a graph of connections among machines available and must decidethe best next stop for packetsheading to a given destination. To do so, it can build


a PathFi nder with itself as the source, then send a packet heading to destinationwto pf. pathTo(w) . next (), the next stop on the shortest path to w. Or a centralauthority might build a PathFi nder for eachof several dependent routers and usethem to issuerouting instructions.The abilityto handlesuch requestsat a high service rate is one of the prime responsibilities of internet routers, and shortest-pathsalgorithms are a critical part of the process.

Shortest-path distances. We define the distance between two vertices to be thelength of the shortest path between them. The first step in understandingbreadth-first search is to consider the problem of computing distances between the sourceand each vertex (the implementation of distanceToQ in PathFinder). Our ap-

initializefor distance 0

distance 1

(LAS)

(LAX) (PHX h-i DFWj^

distance 2

checkfor distance4

queue contents distances from JFK

JFK

ATL DEN DFW HOU JFK LAS LAX MCO ORD

0

JFK

JFK ATL 1

JFK AIL MCO 1

JFK ATI. MCO ORD 1

ATL MCO ORD

ATL MCO ORD HOU .1

MCO ORD HOU 1

ORD HOU

ORD HOU DEN

ORD HOU DEN DFW 1

ORD HOU DEN DFW PHX 1

HOU DEN DFW PHX 1

DEN DFW PHX 1

DEN DFW PHX LAS 1

DFW PHX LAS 1

PHX LAS 1

PHX LAS LAX 1

LAS LAX 1

LAX 1

2 2

2 2

2 2

0

0

0 3

0 3

0 3

0 3

1 1

1 1

1 1

1 1

1 1

1 1

0 3 3 11

0 3 3 I 1

Using breadth-first search to compute shortest path distances in a graph

667


proach is to compute and save awayall the distances in the constructor, and thenjust return the requested value when a client invokes distanceTo(). To associatean integer distance with each vertex name, we use a symbol table:

ST<String, Integer> dist = new ST<String, Integer>();

The purpose of this symbol table is to associate with each vertex an integer: thelength of the shortest path (the distance) from that vertex to s. Webegin by givings the distance 0 with dist. put (s, 0), and we assign to s's neighbors the distance1 with the following code:

for (String v : G.adjacentTo(s))dist.put(v, 1)

But then what do we do? If we blindly set the distances to all the neighbors of eachof those neighbors to 2, then not only would we face the prospect of unnecessarily setting many values twice (neighbors may have many common neighbors), butalso we would set s's distance to 2 (it is a neighbor of each of its neighbors), and weclearlydo not want that outcome. The solution to these difficultiesis simple:

• Consider the vertices in order of their distance from s.

• Ignore vertices whose distance to s is already known.To organize the computation, we use a FIFO queue. Starting with s on the queue,we perform the following operations until the queue is empty:

• Dequeue a vertex v.• Assignall of v's unknown neighbors a distance 1 greater than v's distance.• Enqueue all of the unknown neighbors.

This method dequeues the vertices in nondecreasing order of their distance fromthe source s. Following a trace of this method on a sample graph will help to persuade you that it is correct. Showing that this method labels each vertex v with itsdistance to s is an exercise in mathematical induction (see Exercise 4.5.12).

Shortestpaths tree. We need not only distances from thesource, but also paths. Toimplement pathToO, we use a subgraph known as the shortest-paths tree, definedas follows:

• Put the source at the root of the tree.

• Put vertex v's neighbors in the tree if they are added to the queue, with anedge connecting each to v.


graph

shortest-paths tree

Since we enqueue each vertex only once, this structure isa proper tree: it consists of a root (the source) connectedto one subtree for each neighbor of the source. Studyingsuch a tree, you can see immediately that the distancefrom each vertex to the root in the tree is the same as the

shortest path distance to the source in the graph. Moreimportantly, each path in the tree is a shortest path in thegraph. This observation is important because it gives usan easy way to provide clients with the shortest pathsthemselves (implement pathToO in PathFinder). First,we maintain a symbol table associating each vertex withthe vertex one step nearer to the source on the shortestpath:

ST<String, String> prev;prev = new ST<String, String>();

parent-link representationATL DEN DFW HOU JFK LAS LAX MCO ORD PH

JFK ORF ORD ATL DEN PHX JFK JFK OR

To each vertex w, we want to associate the previous stop Shortest-paths treeon the shortest path from the source to w. Augmenting theshortest-distances method to also compute this information is easy: when we enqueue wbecause we first discover it as a neighbor of v, wedo so precisely becauset v is the previous stop on the shortest path from the sourceto w, so we can call prev.put(w, v). The prev data structure is nothing morethan a representation of the shortest path tree: it provides a link from each node

to its parent in the tree. Then,

shortest-paths tree(parent-link representation)

ATL DEN DFW HOU JFK LAS LAX MCO ORD PHX

JFK ORF ORD ATL DEN PHX JFK JFK ORD


JFK ORF ORD ATI. DEN PHX JFK JFK ORD



ATL DEN DFW HOU JFK. LAS LAX MCO ORD PHX


stack contents

LAX -*— destination

PHX LAX

ORD PHX LAX

.path

JFK ORD PHX LAX

Recovering a pathfrom the tree with a stack

to respond to a client requestfor the path from the sourceto w (a call to pathTo(w) inPathFinder), we follow theselinks up the tree from w, whichtraverses the path in reverseorder, so we push each vertexencountered onto a stack and

then return that stack (an Iterabl e) to the client. At thetop of the stack is s; at the bottom of the stack is v; and the


Program 4.5.4 Shortest-paths implementation

1

£?4

IS

'••?s#

»l

*$i&

public class PathFinder{

private ST<String, String> prev;private ST<String, Integer> dist;

public PathFinder(Graph G, String s)

prev

dist

previous vertex onshortest pathfrom s

distance to s

{ // Use BFS to compute distances and p// on shortest path from s to each veprev = new ST<String, String>();dist = new ST<String, Integer>();Queue<String> q = new Queue<String>()q.enqueue(s);dist.put(s, 0);while (!q.isEmptyO){ // Process next vertex on queue.

String v = q.dequeue();for (String w : G.adjacentTo(v)){ // Check whether distance is al

if (!dist.contains(w)){ // Add to queue and save sho

q.enqueue(w);dist.put(w, 1 + dist.get(v))prev.put(w, v);

revious node

rtex.

mmm

G

s

q

V

w

graphsource

queueof verticescurrent vertex

Ineighbors ofv I

••<mmmmready known,

rtest-path information.

}}

}

PathFi nder ()

distanceToOpathToQ

constructorfor s in Gdistancefrom sfovpath from s tov j

^^^^^^^^^i^^w^^^^^^^^^'

public int distanceTo(String v){ return dist.get(v); }

public Iterable<String> pathTo(String v){ // Return iterable object having shortest path from s to v.

Stack<String> path = new Stack<String>();while (dist.contains(v)){ // Push current vertex; move to previous vertex on path,

path.push(v);v = prev.get(v);

}return path;

}

This class allows clients tofind (shortest) pathsconnecting a specified vertex toother vertices ina graph. SeeProgram 4.5.3 and Exercise 4.5.17for sampleclients.

wm®


vertices on the path from s to v are in between, so the clientgetsthe path from s tov when using the return value from pathToO in a foreachstatement.

Breadth-first search PathFinder (Program 4.5.4) is an implementation of thesingle-source shortest paths API that is basedon the ideas just discussed. It maintains two symbol tables, one for the distance from eachvertex to the source andthe other for the previous stop on the shortestpath from the source to eachvertex.The constructoruses a queueto keep trackof vertices that have been encountered(neighbors of vertices to which the shortest pathhasbeenfoundbut whose neighbors have not yetbeenexamined). Theprocess is referred to asbreadth-first search(BFS) because it searches broadly in the graph. By contrast, another importantgraph-search method known as depth-first search is basedon a recursive methodlikethe one weused for percolation in Program 2.4.5 and searches deeply into thegraph. Depth-first search tends to find long paths; breadth-first search is guaranteed to find shortest paths.

Performance. The costof graph-processing algorithms typically depends on twographparameters: the numberof vertices Vand the numberof edges E. As implemented in PathFinder, the time required by breadth-first search is linearithmic inthe size of the input, proportional to E log V. To convince yourselfof this fact, firstobserve that the outer (whi 1e) loop iterates at most V times, once for each vertex,because we are careful to ensure that each vertex is enqueued at most once. Thenobserve that the inner (for) loop iterates a total of at most 2£ times over all iterations, because we are careful to ensure that each edge is examined at most twice,once for each of the two vertices it connects. Each iteration of the loop requires atleast one contai ns() operation and perhaps two put() operations, on symboltables of sizeat most V. This linearithmic-time performance depends upon using asymbol-table implementationlike BST (Program 4.4.3) that hasa linear-timeiterator and logarithmic-time search.

Adjacency matrix representation. Without proper data structures, fast performance for graph-processing algorithms is sometimes not easy to achieve, and soshould not be taken for granted. For example, another graph representation thatis often used,known as the adjacency matrix representation, uses a symboltable tomapvertex namesto integers between 0 and V-1, then maintains a V-by-V bool-ean array with true in the entry in row i and column j (and the entry in row j


and columni) if thereisan edge connecting thevertex corresponding to i with thevertex corresponding to j, and fal se if there isno suchedge. We have already usedsimilar representations in this book, when studying the random surfer model forrankingweb pages in Section 1.6. The adjacency matrix representation is simple,but infeasible for usewith hugegraphs—a graph with a millionvertices wouldrequirean adjacency matrixwitha trillion entries. Understanding thisdistinction forgraph-processing problems makes the difference between solving a problem thatarises in a practical situation and not being able to address it at all.

Breadth-first search is a fundamental algorithm that you could use to find yourway around an airline route map or a big city subway (see Exercise 4.5.34) or innumerous similar situations. As indicated by our degrees-of-separation example,it also is used for countless other applications, from crawling the web or routingpackets on the internet to studying infectious disease, models of the brain, or relationships among genomic sequences. Many of these algorithms involve hugegraphs, so an efficient algorithm isabsolutely necessary.

An important generalization of the shortest-paths model is to associate aweight (which may represent distance or time) with each edge and seek to finda path that minimizes the sum of the edge weights. If you take later courses inalgorithms or in operations research, you will learn a generalization of breadth-first search known as Dijkstra's algorithm that solves that problemin linearithmictime.Whenyou getdirections froma GPS device or a map application on the web,Dikstra's algorithm is the basis for solving the associated shortest-path problems.These important and omnipresent applications are just the tip of an iceberg, becausegraph modelsare much more general than maps.

Small-world graphs Scientists have identified a particularly interesting classof graphs that arise in numerous applications in the natural and social sciences.Small-world graphsare characterized bythe following three properties:

• They are sparse.• They exhibit local clustering of edgesaround vertices.• They have a short average distance between vertices.

We refer to graphs having these three properties collectively asexhibiting thesmall-world phenomenon. The term small world refers to the idea that the preponderance of vertices have both local clustering and short paths to other vertices. Themodifierphenomenon refers to the somewhat unexpectedfact that alldistances are


short in so many sparsegraphswith local clustering that arise in practice. Beyondthe social-relationships applications just considered, small-world graphs havebeenusedto studythe marketingor productsor ideas, the formationand spreadof fameand fads, the analysis of the internet, the construction of secure peer-to-peer networks, the development of routing algorithms, and wireless networks, the designof electrical powergrids, modeling informationprocessing in the human brain, thestudy of phase transitions in oscillators, the spreadof infectious viruses (in bothliving organisms and computers), and many other applications too numerous tolist.Startingwith the seminalwork of Watts and Strogatz in the 1990s, an intensiveamount of researchhas gone into quantifyingthe small-world phenomenon.

Akeyquestionin suchresearch isthefollowing: Given agraph, how can we tellwhether it is a small-world graph ornot? To answer this question, we begin by imposingthe conditionsthat the graph is not small (say, 1,000 vertices or more) andthat it is connected (there exists some path connecting eachpair of vertices). Then,we need to settle on specific thresholds for eachof the small-worldproperties:

• Bysparse, we mean the average vertexdegree is less than 10 lg V.• Bylocally clustered, we mean that a certain quantity known as the cluster

coefficient should be greater than 10%.• Byshort average distance, we mean the average distance between two verti

ces is less than 10 lg V.

Average vertexdegree

vertex degree

A

B

C

G

H

total

4

1

2

2

1

"To-

average degree = 10/5 = 2

Average path length Cluster coefficient

vertex shortestpair path length

1

vertex

edges in neighborhooddegree possible actual

A B A-B A 4 10 5

A C A-C 1 B 1 1 1

A G A-G 1 C 2 3 3

A H A-H 1 G 2 3 3

B C B-A-C 2 H 1 1 1

B G B-A-G 2 totals 18 13

B H B-A-H

C G C-G

C H C-A-H

2

1

2

total possible = ^ _ ^total actual

G H G-A-H

total

2

15

totallengthM0= 1.5

number ofpairs

Calculating small-world graph characteristics

673


The definition of cluster coefficient is a bit more complicated than vertex distance.Weuse a version of a definition suggested byWatts and Strogatz that is not difficultto compute. If a vertexhas tneighbors, the total number of possibleedgesthat connect those neighbors (including the vertex itself) ist(t+1 )/2. Wedefine the cluster coefficient as the percent- completeage of those edges that are in the graph, using the totalsover all the vertices. Thus, if that percentage is greaterthan 10%, we say that most edges are locally clusteredaround the vertices.

To better familiarize you with these definitions,we next define some simple graph models, and considerwhether they describe small-world graphs by checkingwhether they exhibit the three requisite properties.

ring

star

Complete graphs. A complete graph with Vvertices hasV(V—1)/2 edges, one connecting each pair of vertices.Complete graphs are not small-world graphs. They haveshort distances (the distance between all pairs of nodesis 1) and exhibit local clustering (cluster coefficient is 1),but they are not sparse (the averagevertex degree is V— 1,which is much greater than 10 lg V for large V).

Ringgraphs. Suppose that the vertices are the integers 0to V— 1. In a ring graph, edges connect vertex i to vertexi+1 and V— 1 to 0. Ring graphs are also not small-worldgraphs. They are sparse (average vertex degree 2) and exhibit local clustering (cluster coefficient .33), but they donot have short distances (the average distance betweennodes is linear—see Exercise 4.5.22).

globalclustering

Star graphs. In a star graph, edges connect one vertexto each of the others, but there are no other edges. Stargraphs are also not small-world graphs. They are sparse(average vertex degree2) and haveshort distances (average distance between nodesis slightlyless than 2), but they do notexhibit local clustering, because the clustercoefficient is about 4/N (see Exercise 4.5.22).

Three graph models


Theseexamples illustratethat developing a graph model that satisfies all three constraints simultaneously is a puzzling challenge. Take a moment to try to design agraphmodel that you think mightdo so. After youhave thoughtabout this problem,youwill realize that youarelikely to needa program to helpwithcalculations.Also, you mayagree that it is quitesurprising that theyarefound so often in practice. Indeed,you might be wonderingif any graph is a small-world graph!

Choosing 10% for the local clustering threshold instead of someother fixedpercentage is somewhat arbitrary, as is the choice of 10 lg V for the sparsity andshort path length thresholds, but we often do not come close to these borderlinevalues. Forexample, consider the graphdefined bypages on the web connected bylinks. Analysts have estimated that the average distance between two pages on thewebis less than lg V. If there arebillions of pages, this estimate says that the number of clicks to get from one document to another is about 30 (and each time theweb grows by a factor of 1,000, onlyabout 10 more clicks will be needed). Thesereal-world path lengths are very short, much lowerthan our 10 lg Vestimate, which would be over 300 model sparse? £m? ^ifor billions of vertices (but still much, much less than — — —

. complete O • •

Having settledon the definitions, testing wheth- ringer a graph is a small-world graph can still be a sig- star • • °nificant computational burden.As youprobably have Small-world properties ofgraph modelssuspected, the graph-processing data types that wehave been considering provide precisely the tools that we need. The Graph andPathFinder client SmallWorld (Program 4.5.5) implements these tests. Withoutthe efficient data structures and algorithms that wehave been considering, the costof this computation would be prohibitive. Even so, for huge graphs, we need toresort to sampling to get estimatesof some of the quantities.

A classic small-world graph. Our movie-performer graph is not a small-worldgraph, because it isbipartite and therefore hasa very low cluster coefficient. However, the simpler performer relationship graph defined byconnecting twoperformers by an edge if they appeared in the same movie is a classic example of a small-world graph. Since a performer relationship graphhas manymore edges than thecorresponding movie-performer graph, we will work for the moment with thesmaller graph represented by the file moviesG.txt (G-rated movies). Performergraphs are easy to construct from files in the format represented by movi es*. txt.


Eachline representsa movieand gives a set of actors who are connectedbecauseofthat movie (eachslash-delimited string after the first is an actor's name); we builda complete subgraph connecting allpairs of actors in that movie by addinga graphedge connecting each pair. Doing so foreach movie in the database gives a graph movie-performer relationship graphthat connects the performers, as desired.

Note that the movie names are not

relevant in the performer relationshipgraph—only in the performer relationships implied by the movie. One alternative might be to use a Graph implementation that assigns names to edges, notjust vertices, but our movie-performergraph is a much better solution if theedge names are also of interest.

Now, for movi esG. txt, our Smal1-World client tells us that the resultinggraph has 20,734 vertices and 1,784,567edges (so the average vertex degree is139.0, just less than 10 lg V = 143.4),which means it is sparse;its average pathlength is 7.3 (much less than 143.4), soit has short paths; and its cluster coefficient is .92, so it has local clustering.Wehave found a small-world graph! Thesecalculations validate the hypothesis thatsocial relationship graphs of this sort exhibit the small-world phenomenon. Youare encouraged to find other real-worldgraphs and to test them with Small-World.Youwill find many suggestions inthe exercises at the end of this section.

One approach to understandingsomething like the small-world phenomenon is to develop a mathematical modelthat wecanuseto testhypotheses and to makepredictions. We conclude byreturning to the problem of developing a graph model that can help us to better under-

performervertices performer in

two movies

performer relationship graph

performer intwo movies

connections

to other movies

connectionstoother performerincomplete graph.for othermovies

/

complete graphsconnecting allperformers

in the same movie

Two ways to represent the moviedatabase


^M^KiSi

Program 4.5,5 Small-world test

public class SmallWorld{

public static double avgDegree(Graph G){ return 2*G.E() / G.V(); }

public static double avgDistance(Graph G){ // Compute average vertex distance,

int total = 0;for (String v : G.verticesO){ // Add to total distances from v.

PathFinder pf = new PathFinder(G, v);for (String w : G.verticesO)

total += pf.distanceTo(w);

G

total

v

w

677

• . •• -.- ..•-v.s-aMSfli-'«::->-

graph

cumulative sum ofdistances between vertices

vertex iterator variable

neighbors o/v

sEswffiwf

I

return (double) total / (G.V() * (G.V() - 1));}

public static double clusterCoeff(Graph G){ // Compute cluster coefficient,

int possible = 0;int edges = 2*G.E();for (String v : G.verticesO){ // Cumulate local edge totals,

for (String u : G.adjacentTo(v))for (String w : G.adjacentTo(v))

if (G.hasEdge(u, w)) edges++;int t = G.degree(v);possible += (t + l)*t;

}return (double) edges / possible;

}

public static void main(String[] args){ /* See Exercise 4.5.19. */ }

possible

edges

v

u, w

graph

cumulative sum ofpossible local edges

cumulative sum ofactual localedges

vertex iterator variable

neighbors ofvmBmmmmmmkmmm

This client reads agraphfrom standard input and computes the values ofvarious graph parameters to test whether the graph exhibits the small-world phenomenon.

% Java MoviesToPerformers "/" < moviesG.txt | Java SmallWorld20734 vertices

average degree 139.0average distance 7.3cluster coefficient .92

^^^^^S^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^S^S^s?^^^^^ wmmmmw


public class MoviesToPerformers{


String delimiter = args[0];while (!Stdln.isEmptyO){

String line = Stdln. readLineO ;String[] names = line.split(delimiter);for (int i = 1; i < names.length; i++)

for (int j = i+1; j < names.length; j++)StdOut.println(names[i] + delim + names[j]);

}}

}

% Java MoviesToPerformers "/" < moviesG.txt > performersG.txt% more performersG.txt

DeBoy, David/Blumenfeld, Alan

DeBoy, David/Geppi, CindyDeBoy, David/Hershey, Barbara

Blumenfeld, Alan/Geppi, CindyBlumenfeld, Alan/Hershey, Barbara

Converting the movie-performer graph to aperformer-performer graph

stand the small-world phenomenon. The trick to developing such a model is tointroduce random edges.

Random graphs. One well-studied graph model is the random graph. The simplest way to generate a random sparse graph is to add edges connecting randomvertices, each chosen from Vpossibilities, untilEdifferent edges have beengenerated. Sparse random graphs witha sufficient number of edges are known to haveshort distances but are not small-world graphs, because they do not exhibit localclustering—see Exercise4.5.41.

Ring graphs with random shortcuts. One ofthemost surprising facts to emergefrom the work of Watts and Strogatz is that adding a relatively small number ofrandom edges to a graph with local clustering produces small-world graphs. Togainsomeinsight on whythisisthe case, consider a ringgraph,where the distances


between vertices on opposite sides is ~V72. Adding ~V/2 edges around the ringconnecting vertexi to vertexi+2 (mod V) cuts the lengthof theselongestshortestpaths to ~V74, but adding just one shortcut across the graph accomplishes about

the same effect. Adding V/2 random shortcuts just increases the average number of neighborsby 1and does notsignificantly affect the local clustering, but it is extremelylikely to yielda short average path length.Addingrandomshortcuts to a ring graph does the trick: adding a randomedge from each vertex adds only 1 to the average vertexdegree and does not lower the cluster coefficient much below 1, but it does significantly lower the average distancebetween vertices, making them logarithmic.

random

ringwith random shortcuts

Two additional graph models

Generators that create graphs drawn from such modelsare simpleto develop, and we can use SmallWorld to determine whether the graphs exhibit the small-world phenomenon. We also can check the analytic results that wederived for simple graphs such as tiny.txt, completegraphs, and ring graphs. As with most scientific research,newquestions arise asquickly asweanswer old ones.Howmany random shortcuts do we need to add to get a shortaverage path length? What is the average path length andthe cluster coeffi

cient in a random

graph? What other graph models might beappropriate for study? How many samplesdo we need to accurately estimate the cluster coefficient or the average path lengthin a huge graph? You can find in the exercises many suggestionsfor addressingsuchquestions and for further investigations ofthe small-world phenomenon. With thebasic tools and the approach to programming developed in this book, you are wellequipped to address this and many otherscientific questions.

modelaveragedegree

averagepath length

cluster.coefficient

complete999

O

1

•

1.0

•

ring2

•

250

O

.66

•

star2

•

2

•

.004

O

3V random edges3

•

3

•

.02

O

ringwith Vrandom shortcuts

3

•

3

•

.62

•

Small-world parametersfor various 1,000-vertex graphs


Lessons Thiscase studyillustrates the importance of algorithms and datastructures in scientific research. It also reinforces several of the lessons that we have

learnedthroughout this book,whichareworth repeating.

Carefully design your data type. One of our most persistent messages throughout thisbook is that effective programming isbasedon a precise understandingofthe possible set of data-type values and the operations on them. Using a modernobject-oriented programming languages such as Java provides a path to this understandingbecause wedesign, build,and useour own data types. Our Graph datatype is a fundamentalone, the product of manyiterationsand experience with thedesign choices that wehave discussed. The clarityand simplicity of our clientcodeis testimonyto the valueof takingseriouslythe designand implementation of basicdata types in any program.

Develop code incrementally. As with allof our other case studies, webuild softwareone moduleat a time,testing and learning about eachmodulebeforemovingto the next.

Solve problems that you understand before addressing the unknown. Ourshortest-paths example involving air routes between a few cities is a simple onethat is easyto understand. It is just complicated enough to hold our interestwhiledebugging and following through a trace,but not so complicated as to makethesetasks unnecessarily laborious.

Keep testing and check results. When working with complex programs that process huge amounts of data,you cannot be too careful in checking your results. Usecommon senseto evaluate everybit of output that your program produces.Noviceprogrammers have an optimistic mindset ("if the program produces an answer,it must be correct"); experienced programmers know that a pessimistic mindset("theremust be somethingwrongwith this result") is far better.

Use real-world data. The movies. txt file from the Internet Movie Database isjust one example of the data files that are now omnipresent on the web. In pastyears, such data was often cloaked behind private or parochial formats, but mostpeopleare now realizing that simple text formats are much preferred. The variousmethods in Java's Stri ng data type make it easy to work with real data, which is


the best wayto formulate hypothesesabout real-worldphenomena. Start workingwith small files in the real-world format, so that you can test and learn about performance before attacking huge files.

Reuse software. Another of our most persistent messages isthat effective programming isbasedon an understanding of thefundamental data types available for our use, so that we do nothave to rewrite code for basic functions. Our use of ST and SET

in Graph is a prime example—most programmers still use lower-level representations and implementations that use linkedlists or arrays for graphs, which means, inevitably, that they arerewriting code for simple operations such as maintaining and (^set^) ( st ^traversing linked lists. Our shortest-paths class PathFinderuses Graph, ST, SET, Stack, and Queue, an all-star lineup offundamental data structures.

681

Code reusefor Pathfi nder

Maintain flexibility. Reusing software often means using Java library classes.Theseclasses are generallyverywide interfaces (manymethods), so it is always wiseto defineand implementyour ownAPIs withnarrowinterfaces betweenclientsandimplementations, even if your implementationsare all calls on Java library methods.Thisapproachprovides the flexibility that you needto switch to more effectiveimplementations when warranted and avoids dependence on changes to parts ofthe library that you do not use. For example, using ST in our Graph implementations gives us the flexibility to use Java's Java, uti 1.TreeMap or our BST symbol-table implementation without having to change Graph at all.

Performance matters. Withoutgood algorithms anddatastructures, manyof theproblems that we haveaddressedin this chapterwould go unsolved, becausenaivemethods require an impossible amount of time or space.Maintaining an awarenessof the approximate resource needs of our programs is essential.

This case study is an appropriateplace to end the book because the programs thatwe have considered are a starting point, not a complete study.This book is a starting point, too, for your further studyin science, mathematics, or engineering. Theapproachto programming and the toolsthat youhave learnedhere should prepareyou well for addressing any computational problem whatsoever.


W+.A

Q. Howmanydifferent graphsare therewith Vgiven vertices?

A. With no self-loops or parallel edges, there are V(V—1)/2 possible edges, eachof which can be present or not present, so the grand total is 2 v(v-i)/2e The numbergrowsto be huge quite quickly, as shown in the following table:

l 8

2vrv-u/2 1 2 8 64 1024 32768 2097152 268435456 68719476736

Thesehuge numbers providesomeinsight into the complexities of socialrelationships. For example, if you just consider the next nine people that you see on thestreet, there are over 68 trillion mutual-acquaintance possibilities!

Q. Can a graphhave a vertex that isnot connected to anyother vertex by an edge?

A. Good question. Such vertices are knownas isolated vertices. Our implementation disallows them.Another implementationmight chooseto allowisolatedverticesby includingan explicit addVertexO method for the adda vertex operation.

Q. Whynot just use a linked-list representation for the neighborsof eachvertex?

A. You can do so,but you are likely to wind up re-implementing basiclinked-listcode as you discoverthat you need the size, an iterator, and so forth.

Q. Whydo theV() and E() querymethods needto have constant-time implementations?

A. It mightseem that most clients would call suchmethods onlyonce, but an extremely common idiom is to use code like

for (int i = 0; i < G.EQ; i++) { }

whichwouldtakequadratictimeifyouwere to usea lazyalgorithmthat counts theedges instead of maintaining an instance variable with the number of edges. SeeExercise 4.5.1.


Q. Why are Graph and PathFinder in separate classes? Wouldn't it make moresense to include the PathFi nder methods in the Graph API?

A. Finding shortest paths is just one of many graph-processing algorithms. Itwould be poor software design to include all of them in a single interface. Pleasereread the discussion of wide interfaces in Section 3.3.

683


3&KSili^

4.5.1 Add to Graph the implementations of V() and E() that return the numberof vertices and edges in the graph, respectively. Make sure that your implementations are constant-time. Hint: For V(), you may assume that the size() method inST is constant-time; for E(), maintain an instance variable that holds the value.

4.5.2 Add a method deg ree () to Graph that takes a St ri ng as input and returnsthe degreeof the named vertex. Usethis method to find the performer in movi es.txt who has appeared in the most movies.

Answer:

public int degree(String v){

if (st.contains(v)) return st.get(v).size();else return 0;

}

4.5.3 Add to Graph a method hasVertexO that takes a Stri ng argument andreturns true if it names a vertex in the graph, and fal se otherwise.

4.5.4 Add to Graph a method hasEdgeO that takes two Stri ng arguments andreturns true if they specifyan edge in the graph, and fal se otherwise.

4.5.5 Create a copy constructor for Graph that takes as argument a graph G, thencreatesand initializes a new, independent copyof the graph. Anyfuture changestoGshould not affect the newly created graph.

4.5.6 Write a version of Graph that supports explicit vertex creation and allowsself-loops, paralleledges, and isolatedvertices. Hint: Usea Queue for the adjacencylists instead of a SET.

4.5.7 Add to Graph a method remove() that takes two String arguments anddeletes the specifiededge from the graph, if present.

4.5.8 Add to Graph a method subgraphO that takes a SET<String> as argument and returns the induced subgraph (the graph comprised of those verticesandall edgesfrom the original graph that connect any two of them).


4.5.9 Write a version of Graph that supports generic vertex types (easy). Then,write a version of PathFi nder that uses your implementation to support findingshortest paths using generic vertex types (more difficult).

4.5.10 Create a version of Graph from the previous exercise to support bipartitegraphs (graphswhose edges all connecta vertex of one generic type to a vertexofanother generic type).

4.5.11 True orfalse: At some point during breadth-first searchthe queue can contain two vertices, one whose distance from the source is 7 and one whose distanceis 9.

Answer: False. The queue can contain vertices of at most two distinct distances dand d+1. Breadth first search examines the vertices in increasing order of distancefrom the source.When examining a vertexat distance d, only vertices of distanced+1 can be enqueued.

4.5.12 Proveby induction on the set of vertices visitedthat PathFi nder finds theshortest path distances from the source to each vertex.

4.5.13 Supposeyou usea stackinsteadof a queue forbreadth-first searchin PathFi nder. Does it still find a path? Does it still correctlycompute shortest paths? Ineach case,prove that it does or givea counterexample.

4.5.14 What would be the effectof using a queue instead of a stack when formingthe shortest path in pathToO?

4.5.15 Add a method isReachable(v) to PathFinder that returns true if thereexistssome path from the source to v, and fal se otherwise.

4.5.16 Write a Graph client that uses the constructor given in the text to read aGraph from a file, then prints the edgesin the graph, one per line.

4.5.17 Implement a PathFinder client AllShortestPaths that builds a PathFi nder for each vertex, with a test client that takes from standard input two-vertexqueries and prints the shortest path connecting them.

685


Answer:

public class AllShortestPaths{


In in = new In(args[0]);Graph G = new Graph(in, " ");ST<String, PathFinder> all paths;allpaths = new ST<String, PathFinder>();for (String s : G.verticesO)

all paths.put(s, new PathFinder(G, s));

while (!Stdln.isEmptyO){

String s = Stdln.readString();String t = Stdln.readString();for (String v : all paths.get(s).pathTo(t))

StdOut.print(" " + v);

}}

}

Modifythis code to useadelimiter, so that you can type the two-string queries onone line (separated by the delimiter) and get as output a shortest chain betweenthem. Note: For movi es. txt, the query strings may both be performers, both bemovies, or be a performer and a movie.

4.5.18 Write a program that plotsaverage distance versusthe number of randomedges as random shortcuts are addedto a ringgraph.

4.5.19 Implement a testclient mai n() for Smal 1Worl d (Program 4.5.5) that produces the output given in the sample runs. Your program should take a delimiteras command-line argument andread the graph from Stdln in our standard edge-list format. You program should be a Graph and PathFinder client that builds thegraph; computes the numberof vertices, average degree, average path length, andcluster coefficient for the graph; and indicates whether the values are too large ortoo small for the graph to exhibit the small-world phenomenon.


Partial answer:


In stdin = new In();String delim = args[0];Graph G = new Graph(stdin, delim);

StdOut.printf("%d vertices", G.V());if (G.V() < 1000){ StdOut.print(" (too small) ");StdOut.println();

double val = avgDegree(G);StdOut.printf("average degree %7.3f", val);if (val > 10.0 * Math.log(G.VO) / Math.log(2)){ StdOut.print(" (too big) ");StdOut.println();

}

4.5.20 Add to Small World a method isSmallWorldO that takes a graph as argument and returns true if the graph exhibits the small-world phenomenon (asdefined by the specific thresholds givenin the text) and fal se otherwise.

4.5.21 Add to Smal 1Worl d a method cl usterCoeffi ci ent () that takes a graphand an integer k as arguments and computes a cluster coefficient for the graphbased on total edgespresent and total edges possibleamong the set ofverticeswithin distance k of each vertex. Your program should produce results identical to themethod in Smal 1Worl d when k is 1.)

4.5.22 Compute the average distance between two vertices in a ringgraph with N vertices, and compute the clustercoefficient of a star graphwith N vertices.

4.5.23 In a k-circle graph (for any givenconstant k),edgesconnect vertex i to vertex i+j (mod V) for all postive j less than k. Write a Smal 1-World and Graph client that generates fc-circle graphs and tests whetherthey exhibit the small-worldphenomenon (firstdo Exercise 4.5.20).

687

3-circlegraph


4.5.24 In a gridgraph, vertices are arranged in an N-by-N grid, with edges connecting each vertex to its neighbors above,below, to the left, andto the right in the grid. Write a SmallWorl d and Graph client thatgenerates grid graphs and tests whether they exhibit the small-world phenomenon (first do Exercise4.5.20).

4.5.25 Extend your solutions of the previous two exercises toalsotakea command-line argument Mand to add Mrandom edgesto the graph. Experiment with your programs for 1,024-vertexgraphs to find small-world graphs with as fewedgesas possible. Grid graph


il^Biliiifl^WifiiS

4.5.26 Large Bacon numbers. Find the performers in movi es. txt with the largest,but finite, Kevin Bacon number.

4.5.27 Histogram. Write a program BaconHistogram that prints a histogram ofKevin Baconnumbers, indicating how many performers from movi es. txt have aBacon number of 0, 1, 2, 3,.... Include a category for those who have an infinitenumber (not connected at all to Kevin Bacon).

4.5.28 Performer graph. As mentioned in the text, an alternate way to computeKevin Baconnumbers is to build a graph wherethere isa vertexfor each performer(but not for each movie), and where two performers are connected by an edgeif they appear in a movie together. Calculate Kevin Bacon numbers by runningbreadth-first searcheson the performer graph. Compare the running time with therunning time on movi es. txt. Explain why this approach is so much slower. Alsoexplainwhat you would need to do to includethe movies alongthe path, ashappensautomatically with our implementation.

4.5.29 Connected components. A connected component in an undirected graph is amaximal set of vertices that are mutually reachable.Write a Graph client CCFi nderthat computes the connected components of a graph. Include a constructor thattakes a Graph as an argument and computes all of the connected components using breadth-first search. Include a method areConnected(v, w) that returns trueif v and ware in the same connected component and fal se otherwise. Also add amethod components () that returns the number of connected components.

4.5.30 Floodfill I image processing. An i mage isa two-dimensional array of Colorvalues (see Section 3.1) that represent pixels. A blob is a collection of neighboringpixels of the same color.Writea Graph clientwhoseconstructor builds a grid graph(seeExercise 4.5.24) from a givenimage and supports the floodfill operation. Givenpixelcoordinates i and j and a color c, change the color of that pixel and all thepixels in the same blob to c.

4.5.31 Word ladders. Write a program Word Ladder that takes two 5-letter stringsfrom the command line, and reads in a list of 5-letter words from standard input,and prints out a shortest word ladder using the words on standard input connecting

689


the two strings (if it exists).Two words can be connected in a word ladder chain ifthey differin exactly one letter. Asan example, the following word ladder connectsgreen and brown:

green greet great groat groan grown brown

Writea simplefilter to get the 5-letterwordsfrom a systemdictionary for standardinput or download a list from the booksite. (This game, originallyknown as doublet, was invented by Lewis Carroll.)

4.5.32 Allpaths. Write a Graph client Al1Paths whose constructor takes a Graphas argument and supports operations to count or print out all simple paths between two given vertices s and t in the graph.A simple path does not revisit anyvertexmore than once.In two-dimensional grids,such paths are referredto as self-avoiding walks (see Section 1.4). It is a fundamental problem in statistical physicsand theoreticalchemistry, e.g., to model the spatialarrangement of linear polymermolecules in a solution. Warning: Theremight be exponentially manypaths.

4.5.33 Percolation. Develop a graph model for percolation, and write a Graph client that performs the same computation as Percol ati on (Program 2.4.5).

4.5.34 Subway graphs. In the Tokyo subway system, routes are labeled by lettersand stops by numbers, such as G-8 or A-3. Stations allowing transfers are sets ofstops. Find a Tokyo subway map on the web, develop a simple database format,and write a Graph client that readsa file and can answershortest-path queries forthe Tokyo subway system. If you prefer, do the Paris subway system, whereroutesare sequences of names and transfers are possible when two routes have the samename.

4.5.35 Directed graphs. Implement a Digraph data type that represents directedgraphs, where the direction of edgesis significant: addEdge(v, w) means to add anedgefrom v to wbut notfrom wto v.Replace adj acentTo () with two methods, oneto give the set of vertices having edges directed to them from the argument vertex,the other to give the setofvertices having edges directed fromthem to the argumentvertex. Explain how PathFi nder would need to be modifiedto find shortest pathsin directed graphs.


4.5.36 Random surfer. Modify your Digraph class of the previous exercise tomake a Mul tiDigraph class that allows parallel edges. For a test client, run a random surfer simulation that matches RAndomSurfer (Program 1.6.2).

4.5.37 Transitive closure. Write a Digraph client Transi ti veCl osu re whose constructor takes a Di graph as an argument and whose method i sReachabl e (v, w)returns true if wis reachable from v along a directed path in the digraph and fal seotherwise. Hint: Run breadth-first search from each vertex, as in All Shortest-

Paths (Exercise 4.5.17).

4.5.38 Cover time. A random walk in a connected undirected graph moves froma vertex to one of its neighbors, each chosen with equal probability. (This processis the random surfer analog for undirected graphs.) Write programs to run experiments so that support the developmentof hypotheses on the number of steps usedto visit everyvertexin the graph.What is the covertime for a completegraph with Vvertices? A ring graph? Can you find a familyof graphs where the cover time growsproportionally to V3 or 2 y?

4.5.39 Center oftheHollywood universe. Wecan measure how good a center KevinBaconis by computing each performer's Hollywood number or average path length.The Hollywood number of Kevin Bacon is the average Bacon number of all theperformers (in its connected component). The Hollywood number of another performer is computed the same way, making that performer the source instead ofKevin Bacon. Compute Kevin Bacon's Hollywood number and find a performerwith a better Hollywood number than Kevin Bacon. Find the performers (in thesame connected component as Kevin Bacon) with the best and worst Hollywoodnumbers.

4.5.40 Diameter. The eccentricity of a vertex is the greatest distance between itand any other vertex.The diameter of a graph is the greatestdistance between anytwo vertices (the maximum eccentricity of any vertex). Write a Graph client Diam-ete r that can compute the eccentricityof a vertexand the diameter of a graph. Useit to find the diameter of the graph represented by movi es. txt.

691


4.5.41 Erdos-Renyi graph model. In the classical random graph model, we builda random graph on Vvertices by including each possible edgewith probabilityp.Write a Graph client to verifythe following properties:

• Connectivity thresholds: Ifp < 1/Vand Vis large, then most of connectedcomponents are small,with the largestlogarithmic in size. If p > l/V, thenthere is almostsurelya giantcomponentcontainingalmostallvertices. Ifp< In VI V, the graph is disconnected with high probability; ifp > In VI V,the graph is connected with high probability.

• Distribution ofdegrees: The distribution of degrees follows a binomialdistribution, centered on the average, so most vertices havesimilardegrees.The probability that a vertex is connected to kother vertices decreasesexponentially in k.

• Nohubs: Themaximum vertex degree whenp is a constantis at most logarithmic in V.

• Little local clustering: The clustercoefficient is close to 0 if the graph issparseand connected.Random graphs are not small-worldgraphs.

• Small diameter: lip > In VI V, the diameter is logarithmic.

4.5.42 Power law ofweb links. The indegrees and outdegrees of pages in the webobeya powerlawthat can be modeledby a preferred attachment process. Supposethat eachwebpagehas exactly one outgoinglink.Eachpageiscreatedone at a time,startingwith a single pagethat points to itself. With probabilityp < 1,it links to oneof the existing pages, chosen uniformly at random.With probability 1—p, it linksto an existing pagewith probability proportional to the number of incominglinksof that page. Thisrule reflects the common tendency fornewweb pages to point topopular pages. Writea programto simulate thisprocess and plot a histogramof thenumber of incoming links.

Partial answer: The fractionof pages with indegree k is proportional to k (_1 f(l~p)).

4.5.43 Watts-Strogatzgraph model. (See Exercise 4.5.25.) Watts and Strogatz proposeda hybridmodelthat contains typical linksof vertices near eachother (peopleknowtheir geographic neighbors), plussomerandomlong-range connectionlinks.Plottheeffect ofadding randomedges to anN-by-iVgrid graphon theaverage path


length and on the cluster coefficient,for N = 100.Do the same for fc-circle graphs,for various values of k up to 10 log V,for V= 10,000

4.5.44 Kleinberg graph model. There is no way for participants in the Watts-Strogatz model to find short paths in a decentralized network. But Milgram's experiment also had a striking algorithmic component—individuals can find shortpaths! Jon Kleinberg proposed making the distribution of shortcuts obey a powerlaw, with probability proportional to the dth power of the distance (in d dimensions).Eachvertexhas onelong-range neighbor.Writea program to generate graphsaccording to this model, with a test client that uses Smal 1Worl d to test whether theyexhibit the small-world phenomenon. Plot histograms to show that the graphs areuniform over all distance scales (same number of links at distances 1-10 as 10-100or 100-1000. Write a program to compute the average lengths of paths obtained bytaking the edge that brings the path as closeto target as possible in terms of latticedistance, and test the hypothesis that this average is proportional to (log V)2.

693

In this closing section, weplaceyour newly-acquiredknowledgeof programmingin a broader contextbybrieflydescribing someof the basicelementsof the world

of computation that you are likely to encounter.It isour hope that this informationwillwhet your appetite to use your knowledge of programming as a platform forlearning more about the role of computation in the world around you.

You now know how to program. Just as learning to drive an SUVis not difficult when you know how to drive a car, learning to program in a different language will not be difficult for you. Many scientists regularly use several differentlanguages, for various different purposes. The primitive data types, conditionals,loops, and functional abstraction of Chapters 1 and 2 (that served programmerswell for the first couple of decades of computing) and the object-oriented programming approach of Chapter 3 (that is usedby modern programmers) are basicmodels found in many programming languages. Your skill in using them and thefundamental data types of Chapter 4 will prepare you to cope with libraries, program development environments, and specialized applications of all sorts. You arealso well-positioned to appreciate the power of abstraction in designing complexsystems and understanding how they work.

The study of computer science is much more than learning to program. Nowthat you are familiar with programming and conversant with computing, you arewell-prepared to learn about some of the outstanding intellectual achievementsof the past century, some of the most important unsolved problems of our time,and their role in the evolution of the computational infrastructure that surroundsus. Perhaps even more significant, as we have hinted throughout the book, is thatcomputation is playing an ever increasing role in our understanding of nature,from genomics to moleculardynamics to astrophysics. Further study of the basicprecepts of computer scienceis certain to pay dividendsfor you.

695

696 Context

fava libraries. TheJava system provides extensive resources foryour use. We havemade extensive use of some Java libraries, such as Math and Stri ng,but have ignored most of them. One of Java's unique features is that a great deal of information about the libraries is readily available online. If you have not yet browsedthrough the Java libraries, now is the time to do so. Youwill find that most of thiscode is for use by professional developers, but there are a number of libraries thatyou are likely to find to be interesting. Perhapsthe most important thing for you tokeep in mind when studyinglibraries is that you do need to use them, but you canuse them. When you find an APIthat seems to meet your needs, take advantageofit, by all means.

Programming environments. You will certainly find yourself using other programming environments besides Java in the future. Many programmers, even experiencedprofessionals, are caughtbetween the past, becauseof huge amounts oflegacycode in old languages such as C, C++, and Fortran, and the future, becauseof the availability of modern tools like Ruby, Python, and JavaScript. Perhaps themost important thing for you to keep in mind when using a programming language is that you do not need to use it. If some other language might better meetyour needs, take advantageof it, by allmeans.Peoplewho insist on stayingwithin asingleprogramming environment, for whatever reason, are missing opportunities.

Scientific computing. In particular, computing with numbers can be verytricky,because of accuracy and precision, so the use of libraries of mathematical functions is certainlyjustified. Manyscientists use Fortran, an old scientific language;many others use Matlab, a language that wasdevelopedspecifically for computingwith matrices. The combination of good libraries and built-in matrix operationsmakesMatlab an attractive choicefor many problems. However, sinceMatlab lackssupport for mutable types and other modern facilities, Java is a better choice formany other problems. You can use both! The same mathematical libraries used byMatlab and Fortran programmersare accessible from Java (and by modern scripting languages).

Computer systems. Properties of specific computersystems once completely determined the nature and extent of problems that could be solved, but now theyhardly intrude. You can still count on having a faster machine with much morememory next year at this time. Strive to keep your code machine-independent,

so that you can easily make the switch. More importantly, the web is playing anincreasingly critical role in commercial and scientificcomputing, as you have seenin many examples in this book. You can write programs that process data that ismaintained elsewhere, programs that interact with programs executing elsewhere,and take advantage of many other properties of the extensive and evolvingcomputational infrastructure. Do not hesitate to do so.Peoplewho investsignificant effortin writing programs for specificmachines,evenhigh-powered supercomputers, aremissing opportunities.

Theoretical computer science. By contrast, fundamental limits on computationhave been apparent from the start and continue to play an important role in determining the kinds of problems that we can address. You might be surprised to learnthat there are some problems that no computer program can solve and many otherproblems, which arise commonly in practice, that are thought to be too difficultto solve on any conceivable computer. Everyone who depends on computation forproblem solving,creativework, or research needs to respect these facts.

You have certainly come a long way since you tentatively created, compiled, andran Hell0W0rid, but you certainly still have a great deal to learn. Keep programming, and keep learning about programming environments, scientific computing,computer systems, and theoretical computer science,and you will open opportunities for yourself that people who do not program cannot even conceive.

697

(() (Gaussianpdf) 194<I> (Gaussian cdf) 194it (pi) 29

Abstract data structure

Seealso API; Encapsulationdeque 602graph 650queue 576random queue 580,602set 632

stack 551

symbol table 608Abstract data type

SeeEncapsulationAbstraction 315

Access modifier 372

Adaptive plot 300-303Albers, Josef 325Algorithm 471-606

binary search 511-519breadth-first search 663-671

brute-force 513

depth-first search 298-299Dijkstra's2-stack571Dijkstra's shortest path 672Euclid's gcd 81,259-260Horner's method 214

insertion sort 521-526

Mandelbrot test 394-397

mergesort 527Newton's method 61

quicksort 548shuffling an array 93Sieve of Eratosthenes 99-101

Aliasingdefined 353

with substrings 493Alpha-blending 334Amortized analysis564Analysis of algorithms

amortized analysis564big-Oh notation 497binary search tree 626-628breadth-first search 671

inner loop 478insertion sort 522

leading term 478memory 490-494mergesort 530order of growth 478-489running time 473-489space-time tradeoff 95tilde notation 478

worst-case 488

Anatomyof a class 377

of a command 128

of a constructor 373

of an expression 17of a for loop 57of an i f statement 47

of an instance method 373

of a pri ntf statement 124of a program 7of a signature 30

of a static method 188

of a whi1e loop 50Animation 143-145

API 29,223,318

Body 458

Charge 318

Color 326

Complex 391,721

Counter 424,721

Deque 602

Document 434

Draw 351,716

Gaussian 223

Graph 655,721Histogram 718

In 345,715

Interval 408

Math 29,714

Out 346,714

PathFinder 663,723

Picture 330,718

Poi nt 409

Queue 577,722

RandomQueue 602

Rational 408

SET 632,720

ST 609,720

Stack 552,720

StdArrayI0 229,719

StdAudi 0 149,718

StdDrawl46,718

Stdln 127,717

StdOut 124,716

StdRandom225,719

699

700

StdStats236,719

StockAccount 398

Stopwatch 718

String 338,717

System.out 28,716

Turtle 382,720

Universe 461

Vector 431,721

APLlanguage 404Applicationsprogramming

interface. See API

Argument variable 187,190Arithmetic expression 17,570Arithmetic overflow.

SeeInteger overflowArray 86-119

as an object 355as an argument 198as a return value 201

assignment 96bounds checking 91copy an 89create an 87

declare an 87

default initialization 87

equality test 96exchange two elements 200indexing 86initialization 87,91

input and output 229,230length 89memory allocation 90memory representation 90memory usage 492multidimensional 107

of objects 355one-dimensional 86

out-of-bounds 91

parallel 399plot an 238

print an 200ragged 106reverse an 89,113

two-dimensional 86,102-110zero-based indexing 112

Array doubling 562Assert statement 446-447

Assignment statementparse an 646with arrays 96with primitive types 16with reference types 353

Associative array 613Associativity 17Audio processing.

SeeDigitalaudioAuto-boxing 569Automatic initialization

of array elements 87,496of instance variables 403

Automatic type conversionSee Type conversion

Auto-unboxing 569Average

of a stream of numbers 130

of elements in an array 89

B

Bacon, Kevin 664

Balanced search tree 632

Barnsleyfern 232Base case 256

Base class 438

Beckett, Samuel 265

Benford'slaw215

Bentley, Jon 543Bernouilli, Jacob 386Bernoulli distribution 225,241vBig-Oh notation 497

Index

Binary number 63Binary operator 17Binary representation

binary search 514number conversion 63

Binary search 511-520binary representation 514exception filter 518in a sorted array 516in a symbol table 636Javalibrary 543to invert a function 214,515to weigh an object 518twenty questions 512

Binary search tree 619-631Seealso Binary treeceiling 639find the maximum 631

find the minimum 631

floor 639

insert into 624-625

order statistics 632,644performance of 626range search 632rank query 644red-black tree 628,632

removal in 631

search in 622

traversal of 628-631

visual representation 620Binary tree

balanced 640

inorder traversal 628

isomorphism between 640leaf in 621

level-order traversal 641

postorder traversal 628preorder traversal 628root of 621

Binomial coefficient 119

Binomial distribution 215

Birthday problem 119,213Bisection search 214

Bit 21

Bitmapped image 329Black-Scholes formula 214

Block statement 46

Bodyof an if statement 46

of a loop 49Booksite 4

bool ean data type 25-27Boolean logic 26Bounding box 138Bouncing ball 144-145,457Box-Muller formula 42,213

Breadth-first search 663-671

break statement 70

Brownian bridge 270-271Brownian island 284

Brownian motion 388

Brown, Robert 388BST.See Binarysearch treeBuffer overflow 91

Bug. See ErrorBuilt-in type 14-45Byte 490byte data type 23

c

C language 3array declaration 112compound assignment 56memory leak 357printf 123

C++ language 3iterators 592

memory leak 357operator overloading 404

Caching 486Calendar 216

Call a method 29

Callback 438

Call by reference 201Calls itself. See Recursion

Carroll, Lewis 690

Case studyN-body simulation 456-469percolation 286-313random web surfer 162-181

small-world 650-693

Cast 31-33

Centroid 156

Chaos 85

with Newton's method 414

char data type 19\n (newline) 19\t (tab) 19\" (quotation mark) 19\\ (backslash) 19

Checksum 82,210

Chord 202,216

Chromatic scale 148

Circular queue 604Class

anatomy of 377as a data type 371as a program 6as a set of methods 218

inner 558,593

nested 558,593

classpath 153,247,307

Client 222

CMYK color format 43,361

Code maintenance 245,681

Code reuse 218,245,306,681

Coin flip 49Collatz function 283

Collection 550

701

Color 324-328

CMYK format 361

Col or API 326

compatibility 327luminance 326

RGB representation 324,361RGB to CMYK conversion 43

to grayscale 327with standard draw 324

Column-major order 105Combination 281-282

Command 128

Command-line argument 8,9Command-line input 121Comment 10

Comparabl e interface 434-436compareToO 436,523

for sorting 523keys in a BST609

Compiler 5,573Compile-time error

See Error

Complex number 390-397Compound assignment 56Computer science 695Concatenation 19

Concert A 147

Concordance 638

Conditional

i f statement 46

switch statement 70-71

Connected component 689Constant

Doubl e.NaN 185

Double.NEGATIVE_INFINITY 36

Double.POSITIVE_INFINITY 36

Integer.MAX_VALUE54

Integer.MIN_VALUE54

Math.E 29

Math.PI 29

702

Constant running time 481Constructor

anatomy of 373default no-argument 403defined 372

overloading a 372conti nue statement 70

Control flow 185

Conversion. See Type conversionConway's game of life312Corner case 228

Cost. SeePerformanceCoulomb's law 317

Coupon collector 97-99,196Crichton, Michael 412Ctrl-c 72,153

ctrl-dl31

ctrl-zl31

Cubic running time 482

D

Dangling el se 75Data abstraction 315,370

Data-driven code 133,163,177Data mining 439-445Data structure 471-693

See also Abstract data struc

ture

array 86binary search tree 619-631linked list 555-558

parallel arrays 399Data type

built-in 14-45

creating a 370-469defined 14

designing a 416-469generic 566immutable 427-429

mutable 427-429

parameterized 566primitive type 36referencetype 316using a 316-369wrapper 569

Day of the week 42Debugging

by printing variables52by tracing code 17compile-time errors 8corner case 228

is difficult 177

run-time errors 8

stress test 228

unit test 227

Declaration statement

array 87primitive type variable 16referencetype variable319instance variable 372

Defensive copy 429Delimiter 659

De Morgan's laws26Dependency graph 243Deprecated method 448Depth-first search 298-299Deque data type 602Dequeue (from a queue) 576Derived class 438

Descartes, Rene 386

Designof a data type 416-469of a library 224-225

Design-by-contract 446Dictionary lookup 611-615Digital audio

chord 202

chromatic scale 148

concert A 147

Index

Fourier series 217

harmonics 202

plotting a wave 241sampling 148save to a file 149

superposition of 202-203visualization of 159

Digital image processingSee Image processing

Digital signalprocessing 147Dijkstra, Edsgar 547,571Dijkstra's algorithm 672Discrete distribution 164,226,

647

Divide-and-conquerbinary search 511binary search tree 622mergesort 527paradigm 541

Dot product 88,200doubl e data type 23-24do-while loop 71Doubling hypothesis 474Dragon curve 44,155,412Drawing. SeeStandard drawingDynamic dispatch 435Dynamic programming 275

E

Einstein, Albert 388el se clause 47

Empirical analysis474Encapsulation 420-426

modular programming 420private modifier 422

End-of-file 131

Enhanced for loopSee Foreach loop

Enqueue (onto a queue) 576

Entropy 367,644equal sO method

with Stri ng data type 338with wrapper types 570inherited from Object 438versus == operator 359-360with Color data type 354with user-defined types 449

Erdos number 666

Erdos, Paul 666

Error

ArraylndexOutOfBounds 12,

91,122

buffer overflow 91

bug 8ClassCast567

defined 8

divide by zero 37FormatConversion 125

loss of precision 33missing return statement 207NoClassDefFound 152

non-static method cannot be

referenced 207

Null Pointer 360,403

NumberFormat 128

off-by-one 890ut0fMemory497

RuntimeException 446

shadowing a variable 407Stack0verflow273,274

syntax 11throw an exception 446uninitialized variable 90

unreachable code 207

variable not initialized 35

Escape sequence 19Euclidean distance 113

Euclid's algorithm 81,259-260Euler, Leonhard 85

Event-based programming 437Exception. See ErrorExceptionfilter 518Exchange.SeeSwapExponential distribution 250,

582

Exponential running time263-264,274-275,482

Exponentiation 29Expression 17

Factorial function 57,256-257

Factoring 68-69false literal 25

Fast Fourier transform 254

Fibonacci sequence 78,274-275FIFO 550

FIFO queue. See QueueFile extension

.class 5,9,20

.csv 349,613,662

.Java 5,9,371

.jpg 146,330

.png 146,330

.wav 149

File format 164,229,399

Filter 134-135,139-140

f i nal modifier 372

Find the maximum

in a binary search tree 631in a linked list 601

in an array 89,200of an arbitrary sequence 154of two numbers 29

Find the minimum

in a binary search tree 631of an arbitrary sequence 154

First-in first-out 550

703

float data type 25Floating-point number 23-25

infinity 25NaN (not a number) 25precision 24with == operator 38

Flood fill 689

Flowchart

i f statement 47

nested loops 58while loop 54

Foreach loopwith arrays 594with Iterable collections 585

for loop 55Formatted printing 124-126Forth language 574Fortran language 696Fourier series 217

Fractal

Barnsley fern 232Brownian bridge 270-272dimension 272

dragon curve 44,412Hilbert curve 412

H-tree 268-269

iterated function system 231Koch curve 385

Mandelbrot set 394-397

plasma cloud 272Sierpinski triangle 231

Fractional Brownian motion

270

Fragilebase class438Frequency count 532-534Function. See Static methodFunction abstraction 315

Functional programming language 437

Function call

704

stack implementation of 574trace 187

tree 261

Gambler's ruin 65-67

Game of life 312

Garbage collection 357Gardner, Martin 412

Gaussian distribution 193,270binomial distribution 241

cdf515

random value 42,213,226library 223

Generic array creation 594Generic type 567-569Genomics 341

Geometric mean 154

Global variable 245,405Google 176Graph 650-693

adjacencymatrix 671bipartite 662breadth-first search 671

complete 674connected component 689diameter 691

directed 690

Erdos-Renyi692Graph API 655,723

parallel edge 656random 678

ring 674self-loop 656shortest path in 663-672transitive closure 691

vertex degree 684Gray code 265-267,282Grayscale 327-331

Great circle 44

Greatest common divisor

259-260

Grep 135,440

H

Hamming distance 282Harmonic mean 154

Harmonic number 60-61,95,191,202,213,257

hashCodeO method

for profiling443inherited from Object 438

Hashing 442Heap-ordered 640Hello, World 6-7Hertz 147

Hexadecimal integer 152Hilbert curve 412

Hilbert, David 412

Histogram 169,380-381Hoare,C.A.R.495

Horner's method 214

H-tree 268-269

Hurst exponent 272Hyperlink 551

i

Identifier 15

i f statement 46-49

Image processing 329-337alpha-blending334convert to grayscale 330digital zoom 369flood fill 689

scaling 332Immutability 427-429

and aliasing354defensive copy429

Index

final modifier and 428-429

of strings 363,427-429, 537of symbol table keys609,635

Implementation 223import directive 361Indentation 58

Index

inverted 643

symbol table client 615this 699

Induction 254,258Infinite loop 72,273Infix notation 570,574Information hiding

See EncapsulationInheritance 434-438

Initialization 16

of array elements 87primitive types 16

Inner class 558,593

Inner loop 478,486Inorder traversal 628

Input and output 120-161for arrays 229In data type 345object-oriented 344-351Out data type 346Stdln library 126StdOut library 123

Insertion sort 521-526

In silico experiment 304Instance. See ObjectInstance method 319

access modifier 372

anatomy of 373calling an 319define an 373

versus static method 323

Instance variable

accessing an 391

access modifier 372

defined 372

initialization of 403

shadowing an 407int data type 21-22Integer overflow21,36,54,544Interface inheritance 434-436

Internet movie database 659

Interpolation 158Interpreter 573Invariant 447

Inverted index 643

Inverting a function 515I/O. SeeInputandoutputIterable collection 585-589,638

with a binary tree 629with a graph 656with a linked list 588

with an array 587Iterable interface 586

Iterated function system 231

J

Java 3

installing 4why use? 10

javac command 5java command 5Java program 4

anatomy of 7compile a 5create a 5

execute a 5

java.uti!.ArrayList 592j ava. uti 1. Ar rays 435, 543java.uti1.Color 326java.uti1.Date 454java.uti1.HashMap 635j ava.uti1.HashSet 635

java.util.Iterator 586

j ava.uti1.Li nkedLi st 592java.util.Stack 594

java.util .TreeMap 632,635j ava.uti1.TreeSet 635Java Virtual Machine 5,573,574Josephus problem 603JVM. See lava Virtual Machine

K

Kevin Bacon game 664Keyword 10k-gram 442Kleinberg, Jon 693Knuth, Donald 474,476,495

Koch curve 385

Last-in first-out 550

Layers of abstraction 445Leading term 478Leap year 27Left-associativity 17lg function 481Library 222LIFO 550

Linearithmic running time 482Linear running time 481Link 557

Linked list 555-562

defined 555

insert into front 556

Node data type 555queue 577-580remove from front 557

reverse a 606

stack 558-562

traverse a 558

visual representation 557

705

Linked structure 471

binary tree 621linked list 555

Lissajous pattern 160Literal

boolean 25

char 19

defined 15

double 23

int 21

null 403

String 19

Little's law 582

In function 30,481

Load balancing 590Local variable 374

Logarithmic running time 481Logarithmic spiral 386Logistic map 85Log-logplot 476Logo language 388Loitering 565long data type 23Longest common prefix

535-536

Longestrepeated substring535-541

Loopbreak statement 70

conti nue statement 70

do-whi 1 e statement 71

foreach statement 585

infinite 72

for statement 55

while statement 49

Luminance 326

706

M

Magritte, Rene 353main() method 6,199

command-line arguments 199in each class 221

Mandelbrot, Benoit 394

Mandelbrot set 394-397

Markov,Andrey 168Markov chain 168

mixing a 171squaring a 171

Markov process 581Mathematical analysis476Mathematical function

closed form 194

implementing 193no closed form 194

Mathematical induction

See Induction

Math library 29,716Matlab 3

matrix operations 696mutable types 447pass by value 208

Matrix 102

addition 105

Hadamardll7,308library 249multiplication 105-106,171sparse 645transpose 114

McCarthy's 91 function 285M/D/l queue 581Mean 154,236

Memoization 275

Memory address. SeePointerMemory allocation 356-358

heap 494of a linked list 555,562

of an array 90stack 494

Memory leak 357,565Memory representation

aliased variables 353

array of objects 355object 321orphaned object 356substring 537two-dimensionalarray 103

Memory usage 490-494arrays 492objects 490-491primitive types 490strings 491substrings 493two-dimensional arrays 493

Mergesort 527-530nonrecursive 604

Method 6

static 184-217

instance 373

Midpoint displacementmethod270-272

Milgram,Stanley650M/M/l queue 599Modular programming 183,

218-219,243-245,420Module 183,220Monochrome luminance

See Luminance

Monte Carlo simulation 286

See also Simulation

Moore's law 484-485

more command 135

Multidimensionalarray 107Mutability

defined 427-429

of arrays 427-429

Index

NaN (not a number) 185Natural ordering 434N-body simulation 456-469Nested class 558,593Nesting 58new operator

with arrays 87with objects 319

Newline character 19

Newton, Isaac 61,84,457

Newton's method 61,186N log N running time

SeeLinearithmic running timeNode data type

in a binary tree 620-621in a linked list 555

Normal distribution

See Gaussian distribution

null literal

array elements 87as a default value 403

defined 403

with linked lists 556

with binary trees 619Null pointer exception 403Number conversion 63,80

Object 315create an 319

identity 354memory representation 321orphaned 356type conversion 322

Object class 438Object-oriented programming

315-469

Off-by one-error 89Operand 17Operating systemdirective

| (piping) 133< (redirect stdin) 132> (redirect stdout) 132

OperatorSee also Separatorcompound assignment 56defined 17

+ (addition) 21+ (string concatenation) 18++ (increment) 56- (subtraction) 21— (decrement) 56* (multiplication) 21,23% (remainder) 21/ (division) 21== (equal to) 26== versus = 359

!= (not equal to) 26> (greater than) 26>= (greater than or equal to)

26

< (less than) 26<= (less than or equal to) 26& (bitwise and) 38&& (logicaland) 25|| (logic or) 25! (logicalnot) 25a (exclusive or) 39() (cast) 31

Operator overloading392,404Order of growth 478-489Order statistic 632,644

Orphaned object 356,565,593Out of memory 497Overflow. SeeInteger overflowOverloading

of constructors 372

of methods 192

of operators 392,404

Pagerank 168Palindrome 340

Papert, Seymour 388Parallel arrays 399Parameterized data type 566

Parse

an assignment statement 646parseDoubleO method 18parselnt() method 18

Passby referencedefined 190

of arrays 199versuspassby value208with objects 354

Passby valuedefined 190

of primitive types 354of references 354

versuspassby reference 208Percolation 286-313

bond 311

directed 303,308

using graphs 690three-dimensional 311

vertical 291-292,310

Performance 472-509

guarantees 488-489Permutation 281

inverse 117

random 93

Phase transition 303

Pi cture data type 330Piping 133

707

Pixel 329

Plasma cloud 272

Plottingexperimental results241function graphs 140,300-303sound waves 241

Pointer

defined 321

safe 355

Poisson process 581Poker 253

Polar coordinates 42,422

Polymorphism 435Pop (from a stack) 551Postcondition 447

Postorder traversal 628

PostScript language 388,574Power law 476,692

Power method 172

Powers of two 52

Precedence order 17

Precondition 447

Preorder traversal 628

Primality test 191Prime number 99

Primitive data type 14converting to string 18type conversion 31-33using a 16

printfO method 124-126,152private access modifier

and encapsulation 422instance method 372

instance variable 372

Probability 171Problem size 473

ProgramAlbersSquares 325

ArrayStackOfStrings 554

Average 130

708

Beckett 267

Bernoulli 242

Binary64

BinarySearch 517

Body460

BouncingBall 145

Brownian 271

BST 625

Cat 347

Charge 375

Charged ient 320

CompareAll 444

Compl ex 393

Counter 425

Coupon 197

CouponCollector 98

DeDup633

DivisorPattern 59

Document 441

Doubli ngStackOfStri ngs

563

DoublingTest 477

Estimate 297

Euclid 259

Eval uate 572

Factors 69

Fade 335

Flip49

FrequencyCount 533

Gambler 66

Gaussian 195,515

GeneFind342

Graph 657

Grayscale 331

Harmonic 61

HelloWorld6

Histogram381

Htree269

IFS 233

Index 617

IndexGraph 661

Insertion 524

InsertionTest 526

IntOps 22

LeapYear27

LinkedStackOfStrings 559

LoadBalance 591

Lookup614

LRS 539

Luminance 328

Mandelbrot 397

Markov 174

MDlQueue 583

Merge528

Newton 186

PathFi nder665,670

Percolation 290

PercPlot302

PlayThatTune 150

PIayThatTuneDeluxe 205

PlotFilterl39

Potential 337

PowersOfTwo53

PrimeSieve 100

Quadratic 24

Queue 578

Randomlnt 33

RandomSeq 122

RandomSurfer 167

RangeFilter 134

Ruler 20

Sample94

Scale 333

SelfAvoidingWalkl09

SmallWorid 677

Spiral 387

Split 350

Sqrt62

Stack 568

StdArrayI0230

Index

StdRandom 226

StdStats 237

StockAccount 401

StockQuote 349

Stopwatch 379

ThreeSum475

TowersOfHanoi 262

Transition 165

Turtle 384

TwentyQuestions 129,512

Universe 463

Vector 432

Visualize 475

Programming 6Promotion 32

private access modifier

instance method 372

static method 220

withmainO 10

Push (onto a stack) 551Pushdown stack. See Stack

Python language 592

Quadratic formula 24-25Quadratic running time 482Quadrature 437Quaternion 411

Queue data type 576-584iterator 589

Queue API 576,722

random 580

with array580with linked list 577-580

Queueing theory 581Quicksort 495,548

R

Raggedarray 106Ramanujan, Srinivasa 82Random integer 33Random number generation

Bernoulli 225

binomial 215

discrete 226

exponential 582Gaussian 42,213,226

Maxwell-Boltzmann 249

StdRandom 224-228

uniform 33,191,226

Random queue 580,602Random simulation

See Simulation

Random surfer 162

Random walk

Brownian motion 388

self-avoiding 107-109two-dimensional 82

Range search 632,642Raphson, Joseph 61Raster image 329Rational number 408

Recurrence relation 264,513

Recursion 254-283

See also Callsitselfinduction 258

base case 258,273

convergence 273depth-first search 298-299excessive memory 274,277excessiverecomputation 274pitfalls of 273-275reduction step 258versus iteration 277

Recursive graphicsBrownian bridge 270-271

Brownian island 284

dragon curve 44,412Hilbert curve 412

H-tree 268-269

Koch curve 385

plasma cloud 272Red-black tree 628,632

Redirection 131-133

of standard input 132of standard output 132

Reduction 531

Refactoringcode 535Reference

declare a variable 319

defined 321

objects versus name 352this 433

Reference type 316Regular expression 339Reserved word 15

return statement 188

Return type 188Return value 29

Reverse

a linked list 601,606

an array 89,113a stream 596

a string 504Reverse Polish notation 574

RGB color format 43,324,361

Ringbuffer 604Root of all evil 495

Row-major order 105RSAcryptosystem 69,259Ruby language 592Ruler function 19,20,57,266

Running timeconstant 481

cubic 482

doubling hypothesis474

709

empirical analysis474exponential 263,275,482-483hypotheses 474linear 481

linearithmic 482

logarithmic 481mathematical analysis 476observations 473

of percolation 296order of growth 478-489predictions 483quadratic 482worst-case 488-489

Run-time error. See Error

Samplingan array 158digital sound 148points in the plane 395to plot a function 140to rescale an image 332without replacement 93

Scaffolding 288-289Scientific method 473

Scientific notation 23

Scope 56,189Screen scraping 346Search

breadth-first 663-671

depth-first 298-299in a binary search tree 622in a sorted array 516

Self-avoiding walk 107-109Semantics 48

Separator[ ] (array indexing) 86{ } (block delimiter) 46{ } (array initializer) 91,104

710

C ) (precedence) 17C ) (method call) 187,319; (statement terminator) 6,46, (delimiter) 91,190. (object accessor) 319,391

Sequential search 516Set data type

defined 632-633

java.util.HashSet 635

java.uti1.TreeSet 635

SET API 632,722

Shepherd, Jessy 369short data type 23Shortest path 663-672Shortest-paths tree 668Shuffling

a linked list 601

an array 93,199,226Side effect

defined 193

design-by-contract447with arrays 199

Sierpinksi triangle231Sieve of Eratosthenes 99-101

Signatureanatomy of 30of a static method 29,187

Similarity search445Simulation

Bernoulli trials 241

birthday problem 119,213coin flip 48coupon collector 97-99,196gambler's ruin 65IFS 231-235

loadbalancing590-591M/D/l queue 584N-body 456-469percolation 286-313point in unit disk 71

random surfer 166-168

self-avoiding walk 107-109SI units 317,461

Six degrees of separation 650Small-world 650-693

Sorting 510-529insertion sort 521-526

mergesort 527-530system sort 435,543

Sound processing.See Digitalaudio

Space-time tradeoff 95,101Spatial vector 430-433Specification problem 417,581Speedy 369Spira mirabilis 386Square root

Math library29Newton's method 61-63

user-defined 185-189

Stackdatatype 551-575and recursion 273

for expression evaluation 570for function calls 574-575

iterator 589

for memory allocation494Stack API 552,720

using a doubling array 562using a linked list 558using an array552

Stack overflow 273,274Standard deviation 154,238Standard drawing 136-146

animation 143-145

color 142

filled shapes 141outline shapes 141rescale 138

StdDraw API 146,718

text 142

Index

Standard input 126-131arbitrary-size input 130end-of-file 131

piping from 133redirection from file 132

Stdln API 127,717

Standardoutput 123-126redirection to file 132

StdOut API 124,716

Standards 417

Statement 6,15

assignment 16asssert 446

block 46

break 70

compound assignment 56continue 70

declaration 16

do-while 71

empty 76for 55

foreach 585

if 46

return 188

switch 70

while 49

stati c keyword 10Static method 184-217

anatomy of 187-188argument variable 187calling 190call trace 204

control flow 185

defining 185function call trace 187

main() 199

multiple arguments 190overloading 192return statement 192

scope 189

side effects 193

signature 187singlereturn value 192terminology 188to organize code 196use in other programs 219with array as return value 201with array as argument 198

Static variable 405

Stationary distribution 168Statistics 236-241

histogram 380-381mean 154,236

median 238

plotting 238-240sampling 93select 632,644

standard deviation 154,238

StdStatsAPI236,719

Tukeyplot 251variance 236

StdArraylO libraryAPI 229,719

defined 229-230

StdAudio libraryAPI 149,718

defined 147-151

StdDraw libraryAPI 146,718

defined 136-146

Stdln libraryAPI 127,717

defined 126-131

stdlib.jar289StdOut

API 124,716

defined 123-142

StdRandom libraryAPI 719

defined 224-228

StdStats libraryAPI 236,719

defined 236-242

Stri ngBui1der class 493,502String data type

API 338,717

as immutable type 363compareToO method 338concatenation 502

defined 19

extract a substring 493literal 19

memory usage 491representationof 537reverse a 504

with ==operator 37String processing338-351Strogatz,Stephen 650Strongly-typedlanguage16Stub 289

Substringextract a 493

memory usage 493substringO method 338

Subtyping 438Suffix array 538Suffix sorting 537Swap

array elements 92,199-200variable values 17

switch statement 70-71

Symboltable data type 608-649as associative array 613binary search 618binary search tree 619-632dictionary lookup 611-615elementary 618indexing 615j ava.uti1.HashMap 635j ava. uti 1 .TreeMap 632,635

711

sequential search 618ST API 609,720

Syntax error 11Systemlibrary

indexing 615currentTimeMillisO 378

out.printfO 124-126out.printO 28

out. pri ntl n() 28

Tab character 19

Taylor series 63,83,194Terminal application 4Text editor 4,5

Text processingSee Stringprocessing

thi s reference 433

Throw an exception 446Tilde notation 478

Timing a program 378-379toStringO method

automatically invoked 359inherited from Object 438with binary trees 629with graphs 658with linked lists 561

with reference types 322Towers of Hanoi 260-264

Trace

changein variables17function call 204

Transition matrix 164

Transitive closure 691

Traversal

inorder 628

level-order 641

postorder 628preorder 628

712

Tree VSee alsoBinarysearch treeSee alsoBinary tree Variable

function call 261 argument 374

H-tree 268 defined 15

true literal 25 global245,405Truth table 25 instance 372,374

Turing, Alan 399 local 374

Turing machine 151 scope of 56,374Turtle graphics 382-389 static 245,405

Twenty questions 128-129,512 visibility of 372Two-dimensional array Variance 236

102-110 Vector 88

column-major order 105 dot product 88,200initialization 102 sparse 645

input and output 229 spatial430-433memory representation 103 Vector API 431,721

memory usage 493 Vector image 329ragged 106 Visibility modifier 372row-major order 105 void literal 10,30,207

Type. SeeData type von Neumann, John 531

Type conversionauto-boxing 569 wauto-unboxing 569objects 322primitive type to Stri ng 18

Watts, Duncan 650

Weighing an object 518

promotion 32Stri ng to primitive type 30

Type parameter 569

while loop 49-54Whitespace 10,126,339Wide interface 418,595,683Worst-case 488-489

u Wrapper type 569

Uniform distribution 43,226 xUninitialized variable

primitive type 35,90 Xor function 39

reference type 322zUnix operating system 123,134

Unreachable code 207 Zero-based indexing 89,112Zipfs law 534

Index


Your FirstProgram1.1.1 Hello, World 6

1.1.2 Usinga command-line argument . 8

Built-in Types ofData1.2.1 Stringconcatenation example. . .201.2.2 Integer multiplication and division 221.2.3 Quadratic formula 241.2.4 Leap year 271.2.5 Castingto get a random integer. .33

Conditionals andLoops1.3.1 Flippinga fair coin 491.3.2 Your firstwhile loop 511.3.3 Computing powers of two . . . . 531.3.4 Your first nested loops 591.3.5 Harmonic numbers 61

1.3.6 Newton's method 62

1.3.7 Converting to binary 641.3.8 Gambler's ruin simulation . . . . 66

1.3.9 Factoringintegers 69

Arrays1.4.1 Samplingwithout replacement . .941.4.2 Coupon collector simulation . . .981.4.3 Sieve of Eratosthenes 100

1.4.4 Self-avoiding random walks . . 109

Inputand Output1.5.1 Generating a random sequence . 1221.5.2 Interactive user input 1291.5.3 Averaging a stream of numbers . 1301.5.4 A simple filter 1341.5.5 Input-to-drawing filter .... 1391.5.6 Bouncing ball 1451.5.7 Digital signal processing . ... 150

Case Study: Random Web Surfer1.6.1 Computing the transition matrix 1651.6.2 Simulating a random surfer . . 1671.6.3 Mixing a Markov chain . ... 174


Static Methods

2.1.1 Newton's method (revisited) . . 1862.1.2 Gaussian functions 195

2.1.3 Coupon collector (revisited) . . 1972.1.4 Playthat Tune (revisited) ... 205

Libraries and Clients

2.2.1 Random number library. . . . 2262.2.2 Array I/O library 2302.2.3 Iterated function systems. . . . 2332.2.4 Dataanalysis library 2372.2.5 Plotting data values in an array . 2392.2.6 Bernoulli trials 242

Recursion

2.3.1 Euclid's algorithm 2592.3.2 Towers of Hanoi 262

2.3.3 Gray code 2672.3.4 Recursive graphics 2692.3.5 Brownian bridge 271

CaseStudy: Percolation2.4.1 Percolation scaffolding 2902.4.2 Vertical percolation detection. . 2922.4.3 Visualization client 295

2.4.4 Percolation probabilityestimate. 2972.4.5 Percolation detection 299

2.4.6 Adaptive plot client 302


Data Types3.1.1 Charged particles 3203.1.2 Albers squares 3253.1.3 Luminance library 3283.1.4 Convertingcolor to grayscale . . 3313.1.5 Image scaling 3333.1.6 Fade effect 335

3.1.7 Visualizing electricpotential . . 3373.1.8 Finding genes in a genome . . . 3423.1.9 Concatenating files 3473.1.10 Screen scraping for stock quotes 3493.1.11 Splitting a file 350

Creating Data Types3.2.1 Charged-particleimplementation 3753.2.2 Stopwatch 3793.2.3 Histogram 3813.2.4 Turtle graphics 3843.2.5 Spira mirabilis 3873.2.6 Complex numbers 3933.2.7 Mandelbrot set 397

3.2.8 Stock account 401

Designing Data Types3.3.1 Complexnumbers (alternate). . 4213.3.2 Counter 425

3.3.3 Spatial vectors 4323.3.4 Document 441

3.3.5 Similarity detection 444

Case Study: N-body Simulation3.4.1 Gravitational body 4603.4.2 N-body simulation 463


Performance4.1.1 3-sum problem 4754.1.2 Validating a doubling hypothesis 477

Sorting andSearching4.2.1 Binarysearch (20 questions) . . 5124.2.2 Bisection search 515

4.2.3 Binarysearch (sorted array) . . 5174.2.4 Insertion sort 524

4.2.5 Doubling test for insertion sort . 5264.2.6 Mergesort 5284.2.7 Frequencycounts 5334.2.8 Longestrepeated substring . . . 539

Stacks and Queues4.3.1 Stack of strings (array) 5544.3.2 Stackof strings (linked list). . . 5594.3.3 Stackof strings (array doubling) 5634.3.4 Generic stack 568

4.3.5 Expressionevaluation 5724.3.6 Generic FIFO queue (linked list) 5784.3.7 M/D/l queue simulation. . . . 5834.3.8 Load balancing simulation . . . 591

Symbol Tables4.4.1 Dictionary lookup 6144.4.2 Indexing 6174.4.3 BSTsymbol table 6254.4.4 Dedup filter 633

Case Study: Small World4.5.1 Graph data type 6574.5.2 Using a graph to invertan index. 6614.5.3 Shortest-paths client 6654.5.4 Shortest-paths implementation . 6704.5.5 Small-world test 677

715

public class System.out/StdOut/Out

Out(String name)

void print(String s)

void println(String s)

void pri ntl n()

void printf(String f, . )

create outputstreamfrom name

print s

prints, followed bynewline

print a new line

formatted print

Note: Methods are static and constructor does not applyfor System. out/StdOut.

public class Math

double abs(double a) absolute value ofadouble max (double a, double b) maximum ofaand bdouble min(double a, double b) minimum ofaand b

Note 1: abs (), max (), andmi n() are defined also for i nt, 1ong, andfloat.

double sin (double theta) sinefunctiondouble cos (double theta) cosinefunctiondouble tan (double theta) tangentfunction

Note2:Angles areexpressed in radians. Use toDeg rees () andtoRadi ans () toconvert.Note 3: Use asi n(), acos (), andatan () forinversefunctions.

double exp(double a)

double log(double a)

double pow(double a, double b)

long round(double a)

double randomO

double sqrt(double a)

double E

double PI

exponential (ea)

natural log(loge a, orIn a)

raise a to thebthpower(ab)

round tothe nearest integer

random numberin [0,1)

square rootof a

valueofe (constant)

valueofTT (constant)

public class Stdln/In

In(String name)

boolean isEmptyO

int readlntO

double readDouble()

long readLongO

boolean readBoolean()

char readCharO

Stri ng readStri ng()

String readLineO

String readAHO

Note:Methods arestaticand constructor does notapplyfor

create inputstreamfrom name

true if nomorevalues, else fal se

reada valueof type i nt

reada valueof type doubl e

reada valueof type long

reada valueof type bool ean

reada valueof type char

reada valueof type Stri ng

readtherestof the line

readthe restof the text

Stdln.

public class String

String(String s)

int length()

char charAt(int i)

String substring(int i, int j)

boolean contains(String sub)

boolean startsWith(String pre)

boolean endsWith(String post)

int indexOf(String p)

int indexOf(String p, int i)

String concat(String t)

int compareTo(String t)

String replaceAll(String a, String b)

String[] split (String delim)

boolean equals(String t)

create a stringwith thesamevalueas s

stringlength

i th character

i th through (j-l)st characters

does string contain sub asa substring?

does string startwith pre?

does stringendwith post?

indexoffirstoccurrence ofp

index offirst occurrence ofp after i

thisstringwith t appended

stringcomparison

result ofchanging as to bs

strings between occurrences o/del i m

is this string's value thesame ast's?

718

public class StdDraw/Draw

Draw() create anew Draw objectvoid line(double xO, double yO, double xl, double yl)void point(double x, double y)

void text(double x, double y, String s)void circle(double x, double y, double r)

void filledCircle(double x, double y, double r)void square(double x, double y, double r)

void filledSquare(double x, double y, double r)void polygon (doubled x, doubl e[] y)void filledPolygon(double[] x, double[] y)

void setXscale(double xO, double xl)

void setYscale(double yO, double yl)void setPenRadius(double r)

void setPenColor(Color c)

void setFont(Font f)

void setCanvasSize(int w, int h)

void clear(Color c)

void show(int dt)

void save(String filename)

Note: Methods are static and constructor does not applyfor StdDraw.

APIs

reset x range to (x0, xt)

resety range to (y0, yx)

setpen radiusto r

setpen colorto c

set textfont to f

set canvas tow-by-h window

clear the canvas; color it c

showall;pausedt milliseconds

save toa . j pg or . pngfile

public class StdAudio

void pi ay(String file)

void pi ay(double[] a)

void pi ay(double x)

void save(String file, double[] a)

double[] read(String file)

playthe given .wast file

playthegiven sound wave

playsamplefor 1/44100 second

save to a .wav file

readfrom a .wavfile

public class StdRandom

int uniform(int N) integer between 0 and N-l

double uniform(double lo, double hi) real between lo and hi

719

boolean bernoulli(double p)

double gaussianO

double gaussian(double m, double s)

int discrete(double[] a)

void shuffle(double[] a)

true with probability p

normal mean 0, standard deviation 1

normal mean m, standard deviation s

i withprobability a [i ]

randomly shuffle thearray a []

public class StdArraylO

double[] readDoublelD()

double[][] readDouble2D()

void print (doubl e[] a)

void print(double[] [] a)

read a one-dimensional array ofdoubl e values

read a two-dimensional array o/doubl e values

print a one-dimensional array o/doubl e values

print a two-dimensional array o/doubl e valuesNote 1. IDformat isan integer Nfollowed byN values.

Note 2. 2D format istwo integers Mand Nfollowed by MxNvalues in row-major order.

Note 3.Methodsfori nt and bool ean are also included.

public class StdStats

double max(double[] a)

double min(double[] a)

double mean(double[] a)

double var(double[] a)

double stddev(double[] a)

double median (doubled a)

void piotPoints(double[] a)

void piotLines(double[] a)

void piotBars(doubled a)

largest value

smallest value

average

sample variance

sample standard deviation

median

plotpoints at (i, a[i ] )

plotlines connecting (i, a [i ] )

plotbars topoints at (i, a [i ] )

Note: overloaded implementations are includedforallnumeric types

720

public class Picture

Picture(String name)

Picture(int w, int h)

int width()

int heightO

Color get(int i, int j)

void set (int i, int j, Color c)

void show()

void save(String name)

public class Stopwatch

create a picturefromafile

create a blank w-by-h picture

return thewidth of thepicture

return theheight of thepicture

return thecolor ofpixel ft j)

set thecolor ofpixel ft j) toc

display theimage ina window

save theimage toafile

APIs

Stopwatch()

double elapsedTi me()

create a new stopwatch andstart it running

return theelapsed timesince creation, in seconds


Hi Stog ram (int N) create adynamic histogram for the Ninteger values in [0, N)

double addDataPoint(int i) add an occurrence ofthe value i

public class Turtle

Turtle(double xO, double yO, double aO) createan^turtkat(X(,y0)facinga0degrees counterclockwisefrom x-axis

void turnLeft(double delta)

void goForward(double step)

rotate del ta degrees counterclockwise

move distance step, drawing a line

721


Counter(String id, int max)

void incrementO

int valueO

String toStringO

create a counter, initialized to 0

increment counter unless its value is max

return thevalueof the counter

string representation

public class Complex

Complex(double real, double imag)

Complex pi us(Complex b)

Complex times(Complex b)

double abs()

double re()

double im()

String toStringO

sumof thisnumber and b

product of this number and b

magnitude

realpart

imaginarypart


public class Vector

Vector(double[] a)

Vector pi us(Vector b)

Vector minus(Vector b)

Vector times(double t)

double dot(Vector b)

double magnitudeO

Vector di rection()

double cartesian(int i)

String toStringO

create a vector with thegiven Cartesian coordinates

sumof thisvector and b

difference ofthis vector andb

scalar product ofthis vector and t

dotproduct ofthis vector andb

magnitude of thisvector

unit vector with same direction as this vector

i th cartesian coordinate of thisvector


722

public class Stack<Item>

Stack<Item>

boolean isEmptyO

void push(Item item)

Item pop()


Queue<Item>()

boolean isEmptyO


Item dequeueO

int length()

create an emptystack

is thestack empty?

push an item onto thestack

pop thestack


is thequeue empty?

enqueuean item

dequeue an item

queue length

public class ST<Key extends Comparable<Key>, Value>

APIs

ST()

void put(Key key, Value v)

Value get(Key key)

boolean contains(Key key)

create a symboltable

put key-value pairintothetable

return value paired with key, nul 1 ifkey notin table

is there a value paired with key?

public class SET<Key extends Comparable<Key»

SET() createa set

bool ean i sEmpty() is the set empty?void add (Key key) add key to the set

boolean contains (Key key) iskey in the set?

public class Graph

Graph()

Graph(In in, String delim)

void addEdge(String v, String w)

int V()

int EC)

Iterable<Stri ng> vertices()

Iterable<String> adjacentTo(String v)

int degree(String v)

boolean hasVertex(String v)

boolean hasEdge(String v, String w)

public class PathFinder

PathFinder(Graph G, String s)

int distanceTo(String v)

Iterable<String> pathTo(String v)

723

create an empty graph

readgraphfrom input stream

add edgev-w

numberof vertices

numberof edges

verticesin thegraph

neighbors o/v

numberof neighbors o/v

is v a vertexin thegraph?

is v-w an edgein thegraph?

createan objectthatfinds paths in Qfrom s

length ofshortestpathfrom s to v in G

shortestpathfrom s to v in G

Introductory Programming in Java™ / Programmingfor Science and Engineering

Engage with Applications

"The authors lead with science and applications, and show how the language is the tool.This is how introductory programming should be taught.. .interesting from the start."

—Ted PawlicW, University of Rochester

Introduction to Programming in Java: An Interdisciplinary Approach is a solid introduction to Javaprogramming that emphasizes its application in familiar scenarios, suchas physical and biological science, engineering, and commercial computing. Thesereal-world explorations foster a foundation of computer science concepts and programming skillswhile illustrating the broad reach of computation.

This bookissuitable for any student who has a general interest in science and engineering, including computer science students. Computer science majors will findthat the book's scientific approach prepares them for advanced concepts later inthe curriculum. Science and engineering majors will learn basic programming in amodern programming environment, which they can then apply to later courses intheir chosen major. Most importantly, students will leam that computation is anintegral part of the modern scientific world.

Highlights:

I Familiar applications from high school mathematics and science help studentsleam basic computer science concepts and help them appreciate that programming is fundamental to scientific research.

"Objects in the middle" approach teaches students basic control structures andfunctions and men instructs them how to use, create, and design classes.Full programming model includes standard libraries for input, graphics, sound,and image processing that students can apply and use from the very beginningof their coursework.

Integrated Companion Website features extensive Java coding examples,additional exercises, and links to associated Web materials, available atwww.aw.com/SedgewickWayne.

Visit www.aw.com/computing for more information aboutAddison-Wesley computing books. To order any of our products,contact ourcustomer service department at (800) 824-7799 or(201) 767-5021 outside of the U.S., orvisit your campus bookstore.

Leading Authors • Quality Products

ISBN-13: 978-0-321-49805-2ISBN-10: 0-321-49805-4

9 0 0 0 0

78032 1"498052

sedgewick - programming in java

Documents