1. Week 7 - Wednesday

2.  What did we talk about last time?  Introduction to arrays  Lab 6

7.  When you declare an array, you are only creating a variable that can hold an array  At first, it holds nothing, also know as null  To use it, you have to create an array, supplying a specific size:  This code creates an array of 100 int s int[] list; list = new int[100]; int[] list; list = new int[100];

8.  You can access an element of an array by indexing into it, using square brackets and a number  Once you have indexed into an array, that variable behaves exactly like any other variable of that type  You can read values from it and store values into it  Indexing starts at 0 and stops at 1 less than the length list[9] = 142; System.out.println(list[9]); list[9] = 142; System.out.println(list[9]);

9.  When you instantiate an array, you specify the length  Sometimes (like in the case of args ) you are given an array of unknown length  You can use its length member to find out int[] list = new int[42]; int size = list.length; System.out.println("List has " + size + " elements"); //prints 42 int[] list = new int[42]; int size = list.length; System.out.println("List has " + size + " elements"); //prints 42

11.  An array takes up the size of each element times the length of the array  Each array starts at some point in computer memory  The index used for the array is actually an offset from that starting point  That’s why the first element is at index 0

12.  We can imagine that we have an array of type int of length 10  Java decides what address in memory is going to be used, but let’s say it starts at 524 1243-967890-2323106 0 1 2 3 4 5 6 7 8 9 524 528 532 536 540 544 548 552 556 560 Addresses Indexes

14.  Arrays are a fixed size list of a single kind of data  A for loop is ideal for iterating over every item and performing some operation  for loops and arrays will crop up again and again  Of course, a while loop can be used with an array, but it rarely is

15.  Imagine that we have an array of int s called list  Let’s use a for loop to sum up those int s  Super easy, just like before  We don’t even need to know how big the array is ahead of time int sum = 0; for( int i = 0; i < list.length; i++ ) sum += list[i]; int sum = 0; for( int i = 0; i < list.length; i++ ) sum += list[i];

17.  Recently, we showed you how to add a set of numbers together as they were input by a user  Although this is a useful technique, not every operation is possible  We can find the sum or the average of the numbers because we only need to see the numbers once  What operation needs to see the numbers more than once?

18.  Variance is a measurement of how spread out numbers are from their mean  To calculate it, you have to calculate the mean first  The formula is:  Where N is the number of elements, x i is the i th element, and is the mean

19.  Given an array of doubles called numbers, here’s the code for finding their variance double average = 0; double variance = 0; double temp; for( int i = 0; i < numbers.length; i++ ) average += numbers[i]; average /= numbers.length; for( int i = 0; i < numbers.length; i++ ) { temp = numbers[i] – average; variance += temp*temp; } variance /= numbers.length; double average = 0; double variance = 0; double temp; for( int i = 0; i < numbers.length; i++ ) average += numbers[i]; average /= numbers.length; for( int i = 0; i < numbers.length; i++ ) { temp = numbers[i] – average; variance += temp*temp; } variance /= numbers.length;

20.  We can represent a deck of cards as an array of 52 items  One easy way is to make each item a String giving the name of the card  We can extend last time's lab and store each of these names in an array

21.  Swapping the values of two variables is a fundamental operation in programming  It is going to become more important in arrays because now the order of variables has become important  The simplest way to swap two variables involves using a third variable as a temporary location

22.  Here is an example of swapping two String s indexed i and j in an array of String s called array int i = in.nextInt(); int j = in.nextInt(); String temp = array[i]; array[i] = array[j]; array[j] = temp; int i = in.nextInt(); int j = in.nextInt(); String temp = array[i]; array[i] = array[j]; array[j] = temp;

23.  Using the swap code, we can do a random shuffling of a deck  To do so, we go through each element of the array, and randomly swap it with any of the later elements for( int i = 0; i < n; i++ ) { exchange = i + (int)(Math.random() * (n - i)); temp = deck[i]; deck[i] = deck[exchange]; deck[exchange] = temp; } for( int i = 0; i < n; i++ ) { exchange = i + (int)(Math.random() * (n - i)); temp = deck[i]; deck[i] = deck[exchange]; deck[exchange] = temp; }

24.  Searching through an array is an important operation  The simplest way to do so is just linear search: check every element in the array  Searching and sorting are really key to all kinds of problems  We’ll cover both topics in depth in a few weeks

26.  Like light, sound is a wave  For those physics buffs here, sound is usually transmitted as a compression wave  In contrast, light is a transverse wave  It doesn’t really matter, we can pretend that sound is a transverse wave

27.  The human ear can hear between about 12 Hz and 20,000 Hz  The higher the frequency of the wave, the higher the frequency of the note  Note (ha, ha) that the A an octave above A440 has twice the frequency  Each half-step is an increase in the frequency by a factor of about 1.06 NoteFrequency A440 B493.88 C523.25 D587.33 E659.26 F698.46 G783.99 A880

28.  We can take a sound:  And reproduce that sound at double the frequency:  Notice that we have to add twice as much information to have the sound fill the same amount of time

29.  The amplitude of a wave is the distance from the trough of a wave to its peak  In sound, amplitude is a measure of volume  The larger the amplitude, the louder the sound Amplitude

30.  We can take a sound:  And make the sound with half the amplitude:  The frequency is exactly the same, but the sound is half as loud

31.  Something that looks like a sine wave is called a pure tone  No real instruments play anything like that  Even the purest real sound has overtones and harmonics  Real sound is the result of many messy waves added together:

33.  On a computer, we cannot record a wave form directly  As usual, we have to figure out a way to store a wave as a series of numbers  We are going to use these numbers to approximate the heights of the wave at various points

34.  As we all know by now, Hertz (Hz) is a unit that means a number of times per second  Equivalent to Hz is s -1  We are going to break down the wave into lots of slices  We are going to have 44,100 slices in a second  Thus, we are slicing at 44,100 Hz

35.  We slice up a wave and record the height of the wave  Each height value is called a sample  By getting 44,100 samples per second, we get a pretty accurate picture of the wave

36.  There are many different formats for sampling audio  In our system, each sample will be recorded as a double  The minimum value of a sample will be -1.0 and the maximum value of a sample is 1.0  A series of samples with value 0.0 represents silence  Our samples will be stored in an array

38.  Audio data on Windows machines is sometimes stored in a WAV file  A WAV file is much simpler than an MP3 because it has no compression  Even so, it contains two channels (for stereo) and can have many different sample rates and formats for recording sound  The StdAudio class lets you read and write a WAV file easily and always deal with a single array of sound, sampled at 44,100 Hz

39.  Everything you’d want to do with sound:  To do interesting things, you have to manipulate the array of samples  Make sure you added StdAudio.java to your project before trying to use it MethodUse double[] read(String file) Read a WAV file into an array of double s void save(String file, double[] input) Save an array of double s (samples) into a WAV file void play(String file) Play a WAV file void play(double[] input) Play an array of double s (samples)

40.  Let’s load a file into an array:  If the song has these samples:  Perhaps samples will contain: String file = "song.wav"; double[] samples = StdAudio.read(file); String file = "song.wav"; double[] samples = StdAudio.read(file); -.9-.7-.6-.4-.2-.1.1.2.3.4.5.6.5.4.3.20-.2-.4

41.  With the audio samples loaded into the array named samples, we can play them as follows: StdAudio.play(samples);

42.  Or, we could generate sound from scratch with StdAudio  This example from the book creates 1 second of the pitch A440: double[] sound = new double[StdAudio.SAMPLE_RATE + 1]; for( int i = 0; i < sound.length; i++ ) sound[i] = Math.sin(2 * Math.PI * i * 440 / StdAudio.SAMPLE_RATE); StdAudio.play(sound); double[] sound = new double[StdAudio.SAMPLE_RATE + 1]; for( int i = 0; i < sound.length; i++ ) sound[i] = Math.sin(2 * Math.PI * i * 440 / StdAudio.SAMPLE_RATE); StdAudio.play(sound);

43.  What if we wanted to play the second half of a sound followed by the first half?  I know, why would we want to do that? double[] samples = StdAudio.read(file); double[] switched = new double[samples.length]; for(int i = 0; i < samples.length/2; i++ ) switched[i + samples.length/2] = samples[i]; for(int i = samples.length/2; i < samples.length; i++ ) switched[i - samples.length/2] = samples[i]; StdAudio.play(switched); double[] samples = StdAudio.read(file); double[] switched = new double[samples.length]; for(int i = 0; i < samples.length/2; i++ ) switched[i + samples.length/2] = samples[i]; for(int i = samples.length/2; i < samples.length; i++ ) switched[i - samples.length/2] = samples[i]; StdAudio.play(switched);

46.  Finish StdAudio  Lab 7

47.  Keep reading Chapter 6 of the textbook  Start working on Project 3  Office hours from 3:30-5pm canceled this Friday due to travel