Announcements You survived midterm 2! No Class / No Office hours Friday

Its all about speed! … well usually, sometimes its about memory Portable devices, low power devices Today we will focus on: What makes computers fast/slow How to reason about algorithms We have seen many ways to do a particular task How do we choose which way we should write our program?

Big speed differences Many of the techniques we’ve learned take no time at all in other applications Select a figure in Word. It’s automatically inverted as fast as you can click. Color changes in Photoshop happen as you change the slider Increase or decrease red? Play with it and see it happen live.

What makes my program fast? Is it that Photoshop is so fast? Or that Python is so slow? It’s some of both—it’s not a simple problem with an obvious answer. We’ll consider two issues: How fast can computers get What’s not computable, no matter how fast you go

What a computer really understands Computers really do not understand Python, nor Java, nor any other language. The basic computer only understands one kind of language: machine language. Machine language consists of instructions to the computer expressed in terms of values in bytes. These instructions tell the computer to do very low-level activities.

Machine language trips the right switches The computer doesn’t really understand machine language. The computer is just a machine, with lots of switches that make data flow this way or that way. Machine language is just a bunch of switch settings that cause the computer to do a bunch of other switch settings. We interpret those switches to be addition, subtraction, loading, and storing. In the end, it’s all about encoding. A byte of switches

Assembler and machine language Machine language looks just like a bunch of numbers. Assembler language is a set of words that corresponds to the machine language. It’s often one-to-one relationship. A word of assembler equals one machine language instruction, typically. (Often, just a single byte.)

Assembler instructions Assembler instructions tell the computer to do things like: Store numbers into particular memory locations or into special locations (variables) in the computer. Test numbers for equality, greater-than, or less-than. Add numbers together, or subtract them.

An example assembly language program LOAD 10,R0; Load special variable R0 with 10 LOAD 12,R1; Load special variable R1 with 12 SUM R0,R1; Add R0 and R1, Put the result in R1 STOR R1,#45; Store the result into memory location #45 Recall that we talked about memory as a long series of boxes. Each one has a location (number) (like #45). The “special variables” are often called “registers”. That is why they begin with the letter “R”.

Assembler -> Machine LOAD 10,R0; Load special variable R0 with 10 LOAD 12,R1; Load special variable R1 with 12 SUM R0,R1; Add R0 and R1, Put the result in R1 STOR R1,#45; Store the result into memory location #45 Might appear in memory as just 12 bytes:

Machine language is executed very quickly Imagine a relatively slow computer today (not latest generation) having a clock rate of 1.5 Gigahertz. What that means exactly is hard to explain, but let’s interpret it as processing 1.5 billion bytes per second. Those 12 bytes would execute inside the computer, then, in 12/1,500,000,000 th of a second!

Other factors affect speed Processor Speed Cache located on the processor Memory speed (and size!) Hard Drive speed Operating System efficiency

Hard Drive Slowest form of storage Unlike RAM, Hard Drive storage is “permanent” It survives after you turn the power off

Storage relationships If you have too little RAM, your computer will store some things on hard disk. It will be slower to bring back into RAM for the computer to use it. The system bus describes how fast things can move around your computer. Network is even slower than the hard drive If you’re grabbing a web page from the network, onto the hard drive, and into RAM, the network speed will be the limiting factor.

How do we compare algorithms? There’s more than one way to search. How do we compare algorithms to say that one is faster than another? Computer scientists use something called Big-O notation It’s the order of magnitude of the algorithm Big-O notation tries to ignore differences between languages, even between compiled vs. interpreted, and focus on the number of steps to be executed.

What question are we trying to answer? If I am given a larger problem to solve (more data), how is the performance of the algorithm affected? If I change the input, how does the running time change?

We want to choose the algorithm with the best complexity We want an algorithm which will be fast A “lower” complexity mean an algorithm will perform better on large input

Finding something in the phone book O(n) algorithm Start from the beginning. Check each page, until you find what you want. Not very efficient Best case: One step Worse case: n steps where n = total entries in phone book Average case: n/2 steps

Implementing a Linear Search – slightly different def findInList(something, alist): status = False for item in alist: if (item == something): status = True return status

Running our Search Algorithm >>> print(findInList ("bear",["apple","bear","cat","dog","elephant"])) True >>> print(findInList ("giraffe",["apple","bear","cat","dog","elephant"])) False

Why is it linear? Step 1) What is the input to the algorithm? Well the function takes a list and an element we are looking for Step 2) How much work are we doing? We compare each element in the list to the element we are looking for Lets assume we can test equality in one “step” or one “unit of work”

Implementing a Linear Search def findInList(something, alist): status = False for item in alist:  how much work we perform if (item == something):  piece of work status = True return status

Implementing a Linear Search – slightly better def findInList(something, alist): for item in alist: if (item == something): return True return False

So why do we bother with linear search? Our data might not be ordered! Notice that our faster algorithms required our data to be ordered We say that ordered data is sorted Challenge question: Is it faster to linearly search through unordered data, or to sort it, and then use a binary search? We will answer this next week!

A better search in a sorted list O(log n) (log 2 n = x where 2 x =n) Split the phone book in the middle. Is the name you’re at before or after the page you’re looking at? If after, look from the middle to the end. If before, look from the start to the middle. Keep repeating until done More efficient: Best case: It’s the first place you look. Average and worst case: log n steps

Implementing a binary search def findInSortedList(something, alist ): start = 0 end = len(alist) – 1 status = False while start <= end: checkpoint = int(( start+end )/2.0) if alist[checkpoint ]== something: return True if alist[checkpoint]<something: start=checkpoint +1 if alist[checkpoint]>something: end=checkpoint -1 return status

print("Checking at: "+str(checkpoint )+" Start:"+str(start )+" End:"+str(end)) >>> findInSortedList("giraffe",["apple","bear","cat”,"dog"]) Checking at: 1 Start :0 End:3 Checking at: 2 Start :2 End:3 Checking at: 3 Start :3 End:3 False >>> findInSortedList("apple” ["apple","bear","cat”,"dog"]) Checking at: 1 Start :0 End:3 Checking at: 0 Start :0 End:0 True >>> findInSortedList("dog",["apple","bear","cat”,"dog"]) Checking at: 1 Start :0 End:3 Checking at: 2 Start :2 End:3 Checking at: 3 Start :3 End:3 True Running the binary search

Clicker Question Did you come to class today? A) yes B) no

Homework Read Chapter 9