Algorithms. What is an algorithm?

Transcription

1

2 What is an algorithm?

3 What is an algorithm? Informally, an algorithm is a well-defined finite set of rules that specifies a sequential series of elementary operations to be applied to some data called the input, producing after a finite amount of time some data called the output.

4 What is an algorithm? Informally, an algorithm is a well-defined finite set of rules that specifies a sequential series of elementary operations to be applied to some data called the input, producing after a finite amount of time some data called the output. The oldest non-trivial algorithm, that has survived to the present day, is the Euclidean algorithm, named after the Greek mathematician Euclid (fl. 300 BC), for computing the greatest common divisor of two natural numbers.

5 What is an algorithm? Informally, an algorithm is a well-defined finite set of rules that specifies a sequential series of elementary operations to be applied to some data called the input, producing after a finite amount of time some data called the output. The oldest non-trivial algorithm, that has survived to the present day, is the Euclidean algorithm, named after the Greek mathematician Euclid (fl. 300 BC), for computing the greatest common divisor of two natural numbers. The word Algorithm derives from the name of a Persian mathematician al-khwārizmī (c c. 850).

6 What is an algorithm? Informally, an algorithm is a well-defined finite set of rules that specifies a sequential series of elementary operations to be applied to some data called the input, producing after a finite amount of time some data called the output. The oldest non-trivial algorithm, that has survived to the present day, is the Euclidean algorithm, named after the Greek mathematician Euclid (fl. 300 BC), for computing the greatest common divisor of two natural numbers. The word Algorithm derives from the name of a Persian mathematician al-khwārizmī (c c. 850). An algorithmic solution to a computational problem will usually involve designing an algorithm, and then analysing its performance.

7

8 What is a computational problem?

9 What is a computational problem? The 15th century Italian mathematician Leonardo Fibonacci is known for his famous sequence of numbers 0, 1, 1, 2, 3, 5, 8, 13, 21, 34,...,

10 What is a computational problem? The 15th century Italian mathematician Leonardo Fibonacci is known for his famous sequence of numbers 0, 1, 1, 2, 3, 5, 8, 13, 21, 34,..., each the sum of its two immediate predecessors.

11 What is a computational problem? The 15th century Italian mathematician Leonardo Fibonacci is known for his famous sequence of numbers 0, 1, 1, 2, 3, 5, 8, 13, 21, 34,..., each the sum of its two immediate predecessors. More formally, F n 1 + F n 2 if n > 1 F n = 1 if n = 1 0 if n = 0.

12 What is a computational problem? The 15th century Italian mathematician Leonardo Fibonacci is known for his famous sequence of numbers 0, 1, 1, 2, 3, 5, 8, 13, 21, 34,..., each the sum of its two immediate predecessors. More formally, F n 1 + F n 2 if n > 1 F n = 1 if n = 1 0 if n = 0. But what is the precise value of F 100, or of F 200? Fibonacci himself would surely have wanted to know such things.

13 What is a computational problem? The 15th century Italian mathematician Leonardo Fibonacci is known for his famous sequence of numbers 0, 1, 1, 2, 3, 5, 8, 13, 21, 34,..., each the sum of its two immediate predecessors. More formally, F n 1 + F n 2 if n > 1 F n = 1 if n = 1 0 if n = 0. But what is the precise value of F 100, or of F 200? Fibonacci himself would surely have wanted to know such things. To answer, we need to design an algorithm for computing the nth Fibonacci number.

14 One approach is to implement the recursive definition of F n.

15 One approach is to implement the recursive definition of F n. Algorithm FIB1(n) 1: if n = 0 then 2: return 0 3: end if 4: if n = 1 then 5: return 1 6: end if 7: return FIB1(n 1) + FIB1(n 2)

16 One approach is to implement the recursive definition of F n. Algorithm FIB1(n) 1: if n = 0 then 2: return 0 3: end if 4: if n = 1 then 5: return 1 6: end if 7: return FIB1(n 1) + FIB1(n 2) There are three questions we always ask about it: 1. Is it correct? 2. How much time does it take, as a function of n? 3. And can we do better?

17 One approach is to implement the recursive definition of F n. Algorithm FIB1(n) 1: if n = 0 then 2: return 0 3: end if 4: if n = 1 then 5: return 1 6: end if 7: return FIB1(n 1) + FIB1(n 2) There are three questions we always ask about it: 1. Is it correct? 2. How much time does it take, as a function of n? 3. And can we do better? The algorithm is definitely correct. It is the definition of F n.

18 Recursive Fibonacci The recursive calls of FIB(6) From CLRS Introduction to Algorithms Chapter 27

19 How much time does FIB1(n) take, as a function of n?

20 How much time does FIB1(n) take, as a function of n? Let T (n) be the number of computer steps needed to compute FIB1(n); what can we say about this function?

21 How much time does FIB1(n) take, as a function of n? Let T (n) be the number of computer steps needed to compute FIB1(n); what can we say about this function? For starters, if n is less than 2, the procedure halts almost immediately, after just a couple of steps.

22 How much time does FIB1(n) take, as a function of n? Let T (n) be the number of computer steps needed to compute FIB1(n); what can we say about this function? For starters, if n is less than 2, the procedure halts almost immediately, after just a couple of steps. T (n) 2 for n 1.

23 How much time does FIB1(n) take, as a function of n? Let T (n) be the number of computer steps needed to compute FIB1(n); what can we say about this function? For starters, if n is less than 2, the procedure halts almost immediately, after just a couple of steps. T (n) 2 for n 1. For larger values of n, there are two recursive invocations of FIB1: one taking time T (n 1) and one taking time T (n 2); plus three other steps (check the value of n and a final addition). T (n) = T (n 1) + T (n 2) + 3 for n > 1.

24

25 Compare this to the recurrence relation for F n : we immediately see that T (n) F n.

26 Compare this to the recurrence relation for F n : we immediately see that T (n) F n. This is very bad news: the running time of the algorithm grows as fast as the Fibonacci numbers. The Fibonacci numbers grow exponentially (not proved here).

27 Compare this to the recurrence relation for F n : we immediately see that T (n) F n. This is very bad news: the running time of the algorithm grows as fast as the Fibonacci numbers. The Fibonacci numbers grow exponentially (not proved here). T (n) is exponential in n, which implies that the algorithm is impractically slow except for small values of n.

28 Compare this to the recurrence relation for F n : we immediately see that T (n) F n. This is very bad news: the running time of the algorithm grows as fast as the Fibonacci numbers. The Fibonacci numbers grow exponentially (not proved here). T (n) is exponential in n, which implies that the algorithm is impractically slow except for small values of n. For example, to compute F 200, algorithm FIB1 executes T (n) F elementary computer steps.

29 Compare this to the recurrence relation for F n : we immediately see that T (n) F n. This is very bad news: the running time of the algorithm grows as fast as the Fibonacci numbers. The Fibonacci numbers grow exponentially (not proved here). T (n) is exponential in n, which implies that the algorithm is impractically slow except for small values of n. For example, to compute F 200, algorithm FIB1 executes T (n) F elementary computer steps. Even on a very fast machine, FIB1(200) would take more than 2 92 seconds.

30 Compare this to the recurrence relation for F n : we immediately see that T (n) F n. This is very bad news: the running time of the algorithm grows as fast as the Fibonacci numbers. The Fibonacci numbers grow exponentially (not proved here). T (n) is exponential in n, which implies that the algorithm is impractically slow except for small values of n. For example, to compute F 200, algorithm FIB1 executes T (n) F elementary computer steps. Even on a very fast machine, FIB1(200) would take more than 2 92 seconds. If we start the computation today, it would still be unfinished long after the sun turns into a red giant star.

31 Compare this to the recurrence relation for F n : we immediately see that T (n) F n. This is very bad news: the running time of the algorithm grows as fast as the Fibonacci numbers. The Fibonacci numbers grow exponentially (not proved here). T (n) is exponential in n, which implies that the algorithm is impractically slow except for small values of n. For example, to compute F 200, algorithm FIB1 executes T (n) F elementary computer steps. Even on a very fast machine, FIB1(200) would take more than 2 92 seconds. If we start the computation today, it would still be unfinished long after the sun turns into a red giant star. The algorithm is correct, but can we do better?

32

33 A faster approach could be store the intermediate results: the values F 0, F 1,..., F n 1.

34 A faster approach could be store the intermediate results: the values F 0, F 1,..., F n 1. Algorithm FIB2(n) 1: if n 1 then 2: return n 3: end if 4: f [0... n] 0 5: f [0] 0 6: f [1] 1 7: for all i [2, n] do 8: f [i] f [i 1] + f [i 2] 9: end for 10: return f [n]

35 A faster approach could be store the intermediate results: the values F 0, F 1,..., F n 1. Algorithm FIB2(n) 1: if n 1 then 2: return n 3: end if 4: f [0... n] 0 5: f [0] 0 6: f [1] 1 7: for all i [2, n] do 8: f [i] f [i 1] + f [i 2] 9: end for 10: return f [n] The correctness of this algorithm follows by definition of F n.

36 Algorithm FIB2

37 Algorithm FIB2 How long does it take?

38 Algorithm FIB2 How long does it take? The for loop (lines 7-8) consists of a single computer step and is executed n 1 times.

39 Algorithm FIB2 How long does it take? The for loop (lines 7-8) consists of a single computer step and is executed n 1 times. Therefore the number of computer steps used by FIB2(n) is linear in n.

40 Algorithm FIB2 How long does it take? The for loop (lines 7-8) consists of a single computer step and is executed n 1 times. Therefore the number of computer steps used by FIB2(n) is linear in n. From exponential we are down to polynomial, a huge breakthrough in running time.

41 Algorithm FIB2 How long does it take? The for loop (lines 7-8) consists of a single computer step and is executed n 1 times. Therefore the number of computer steps used by FIB2(n) is linear in n. From exponential we are down to polynomial, a huge breakthrough in running time. It is now perfectly reasonable to compute F 200 or even F 200,000.

42 Brief discussion What was the difference in design between these two algorithms? The second algorithm is faster than the first when run on a single processor. The first algorithm is recursive, and used a divide-and-conquer approach to split the problem into sub-problems The second algorithm is completely sequential, building F n from our previous knowledge of F n 1 and F n 2. The sequential running time of the second algorithm is best possible (optimal). We need n steps to compute F n.

43 Running time of Algorithms

44 Running time of Algorithms Instead of reporting that an algorithm takes, say, 5n 3 + 4n + 3 steps on an input of size n, it is much simpler to leave out lower-order terms such as 4n and 3 (which become insignificant as n grows).

45 Running time of Algorithms Instead of reporting that an algorithm takes, say, 5n 3 + 4n + 3 steps on an input of size n, it is much simpler to leave out lower-order terms such as 4n and 3 (which become insignificant as n grows). Even the detail of the coefficient 5 in the leading term computers will be five times faster in a few years anyway.

46 Running time of Algorithms Instead of reporting that an algorithm takes, say, 5n 3 + 4n + 3 steps on an input of size n, it is much simpler to leave out lower-order terms such as 4n and 3 (which become insignificant as n grows). Even the detail of the coefficient 5 in the leading term computers will be five times faster in a few years anyway. We just say that the algorithm takes time O(n 3 ) (pronounced big oh of n 3 ).

47 Running time of Algorithms Instead of reporting that an algorithm takes, say, 5n 3 + 4n + 3 steps on an input of size n, it is much simpler to leave out lower-order terms such as 4n and 3 (which become insignificant as n grows). Even the detail of the coefficient 5 in the leading term computers will be five times faster in a few years anyway. We just say that the algorithm takes time O(n 3 ) (pronounced big oh of n 3 ). We define this notation precisely by thinking of f (n) and g(n) as the running times of two algorithms on inputs of size n.

48 Definition Let f (n) and g(n) be functions from positive integers to positive reals. We say f = O(g) (which means that f grows no faster than g ) if there is a constant c > 0 such that f (n) c.g(n).

49

50 Saying f = O(g) is a very loose analog of f g.

51 Saying f = O(g) is a very loose analog of f g. It differs from the usual notion of due to the constant c.

52 Saying f = O(g) is a very loose analog of f g. It differs from the usual notion of due to the constant c. This constant also allows us to disregard what happens for small values of n.

53 Saying f = O(g) is a very loose analog of f g. It differs from the usual notion of due to the constant c. This constant also allows us to disregard what happens for small values of n. Suppose f 1 (n) = n 2 and f 2 (n) = 2n Which is better (smaller)?

54 Saying f = O(g) is a very loose analog of f g. It differs from the usual notion of due to the constant c. This constant also allows us to disregard what happens for small values of n. Suppose f 1 (n) = n 2 and f 2 (n) = 2n Which is better (smaller)? Well, this depends on the value of n. For n 5, f 1 is smaller; thereafter, f 2 is the clear winner.

55 Saying f = O(g) is a very loose analog of f g. It differs from the usual notion of due to the constant c. This constant also allows us to disregard what happens for small values of n. Suppose f 1 (n) = n 2 and f 2 (n) = 2n Which is better (smaller)? Well, this depends on the value of n. For n 5, f 1 is smaller; thereafter, f 2 is the clear winner. In this case, f 2 scales much better as n grows, and therefore it is smaller.

56

57 This superiority is captured by the big-o notation: f 2 = O(f 1 ), because

58 This superiority is captured by the big-o notation: f 2 = O(f 1 ), because for all n. f 2 (n) 2n + 20 = f 1 (n) n 2 22

59 This superiority is captured by the big-o notation: f 2 = O(f 1 ), because for all n. f 2 (n) 2n + 20 = f 1 (n) n 2 22 On the other hand, f 1 O(f 2 ), since the ratio

60 This superiority is captured by the big-o notation: f 2 = O(f 1 ), because for all n. f 2 (n) 2n + 20 = f 1 (n) n 2 22 On the other hand, f 1 O(f 2 ), since the ratio f 1 (n) f 2 (n) = n2 2n + 20

61 This superiority is captured by the big-o notation: f 2 = O(f 1 ), because for all n. f 2 (n) 2n + 20 = f 1 (n) n 2 22 On the other hand, f 1 O(f 2 ), since the ratio f 1 (n) f 2 (n) = n2 2n + 20 can get arbitrarily large, and so no constant c will make the definition work.

62

63 2n + 20 = O(n 2 )

64

65 Suppose f 1 (n) = n 2, f 2 (n) = 2n + 20, and f 3 (n) = n + 1?

66 Suppose f 1 (n) = n 2, f 2 (n) = 2n + 20, and f 3 (n) = n + 1? We see that f 2 = O(f 3 ), because

67 Suppose f 1 (n) = n 2, f 2 (n) = 2n + 20, and f 3 (n) = n + 1? We see that f 2 = O(f 3 ), because f 2 (n) 2n + 20 = f 3 (n) n ,

68 Suppose f 1 (n) = n 2, f 2 (n) = 2n + 20, and f 3 (n) = n + 1? We see that f 2 = O(f 3 ), because f 2 (n) 2n + 20 = f 3 (n) n , but also f 3 = O(f 2 ), this time with c = 1.

69 Suppose f 1 (n) = n 2, f 2 (n) = 2n + 20, and f 3 (n) = n + 1? We see that f 2 = O(f 3 ), because f 2 (n) 2n + 20 = f 3 (n) n , but also f 3 = O(f 2 ), this time with c = 1. Just as O(.) is an analog of we can also define analogs of and = as follows.

70

71 Definition Let f (n) and g(n) be functions from positive integers to positive reals. f = Ω(g) means g = O(f ).

72 Definition Let f (n) and g(n) be functions from positive integers to positive reals. f = Ω(g) means g = O(f ). Definition Let f (n) and g(n) be functions from positive integers to positive reals. f = Θ(g) means f = O(g) and f = Ω(g).

73 Definition Let f (n) and g(n) be functions from positive integers to positive reals. f = Ω(g) means g = O(f ). Definition Let f (n) and g(n) be functions from positive integers to positive reals. f = Θ(g) means f = O(g) and f = Ω(g). Example 2n + 20 = Θ(n + 1) and n 2 = Ω(n + 1).

74 Here are some commonsense rules that help simplify functions by omitting dominated terms:

75 Here are some commonsense rules that help simplify functions by omitting dominated terms: Multiplicative constants can be omitted: 14n 2 becomes n 2.

76 Here are some commonsense rules that help simplify functions by omitting dominated terms: Multiplicative constants can be omitted: 14n 2 becomes n 2. n a dominates n b if a > b: for instance, n 2 dominates n.

77 Here are some commonsense rules that help simplify functions by omitting dominated terms: Multiplicative constants can be omitted: 14n 2 becomes n 2. n a dominates n b if a > b: for instance, n 2 dominates n. Any exponential dominates any polynomial: 3 n dominates n 5.

78 Here are some commonsense rules that help simplify functions by omitting dominated terms: Multiplicative constants can be omitted: 14n 2 becomes n 2. n a dominates n b if a > b: for instance, n 2 dominates n. Any exponential dominates any polynomial: 3 n dominates n 5. Likewise, any polynomial dominates any logarithm: n dominates (log n) 3. This also means, for example, that n 2 dominates n log n.

79 Parallel Algorithms: What? Devising algorithms which allow many processors to work collectively to solve:

80 Parallel Algorithms: What? Devising algorithms which allow many processors to work collectively to solve: the same problems, but faster

81 Parallel Algorithms: What? Devising algorithms which allow many processors to work collectively to solve: the same problems, but faster bigger/more refined problems in the same time

82 Parallel Algorithms: What? Devising algorithms which allow many processors to work collectively to solve: the same problems, but faster bigger/more refined problems in the same time when compared to a single processor.

83 Parallel Algorithms: Why? Because it is an interesting intellectual challenge!

84 Parallel Algorithms: Why? Because it is an interesting intellectual challenge! Because parallelism is everywhere and we need algorithms to exploit it.

85 Parallel Algorithms: Why? Because it is an interesting intellectual challenge! Because parallelism is everywhere and we need algorithms to exploit it. Global scale: computational grids

86 Parallel Algorithms: Why? Because it is an interesting intellectual challenge! Because parallelism is everywhere and we need algorithms to exploit it. Global scale: computational grids Supercomputer scale: Top 500 HPC, scientific simulation, financial modeling, Google,

87 Parallel Algorithms: Why? Because it is an interesting intellectual challenge! Because parallelism is everywhere and we need algorithms to exploit it. Global scale: computational grids Supercomputer scale: Top 500 HPC, scientific simulation, financial modeling, Google, Desktop scale: commodity multicore PCs and laptops

88 Parallel Algorithms: Why? Because it is an interesting intellectual challenge! Because parallelism is everywhere and we need algorithms to exploit it. Global scale: computational grids Supercomputer scale: Top 500 HPC, scientific simulation, financial modeling, Google, Desktop scale: commodity multicore PCs and laptops Specialised hardware: custom parallel circuits for key operations such as encryption, and multimedia (NVIDIA)

89 Parallel Algorithms: How? We will need

90 Parallel Algorithms: How? We will need machine model(s) which tell us what the basic operations are in a reasonably abstract way

91 Parallel Algorithms: How? We will need machine model(s) which tell us what the basic operations are in a reasonably abstract way cost model(s) which tell us what these operations cost, in terms of resources we care about (usually time, sometimes memory)

92 Parallel Algorithms: How? We will need machine model(s) which tell us what the basic operations are in a reasonably abstract way cost model(s) which tell us what these operations cost, in terms of resources we care about (usually time, sometimes memory) analysis techniques which help us map from algorithms to costs with acceptable accuracy

93 Parallel Algorithms: How? We will need machine model(s) which tell us what the basic operations are in a reasonably abstract way cost model(s) which tell us what these operations cost, in terms of resources we care about (usually time, sometimes memory) analysis techniques which help us map from algorithms to costs with acceptable accuracy metrics which let us discriminate between costs (e.g. speed v. efficiency)

94 Parallel Computer Structures Dominant programming models reflect an underlying architectural divergence:

95 Parallel Computer Structures Dominant programming models reflect an underlying architectural divergence: the shared address space model allows threads (or lightweight processes) to interact directly through common memory locations. Care is required to avoid unintended interactions (races).

96 Parallel Computer Structures Dominant programming models reflect an underlying architectural divergence: the shared address space model allows threads (or lightweight processes) to interact directly through common memory locations. Care is required to avoid unintended interactions (races). We consider two simplified models multi-threading and PRAM

97 Parallel Computer Structures Dominant programming models reflect an underlying architectural divergence: the shared address space model allows threads (or lightweight processes) to interact directly through common memory locations. Care is required to avoid unintended interactions (races). We consider two simplified models multi-threading and PRAM the message passing model gives each process its own address space. Care is required to distribute the data across these address spaces and to communicate results between them by sending and receiving messages as appropriate.

98 Parallel Computer Structures Dominant programming models reflect an underlying architectural divergence: the shared address space model allows threads (or lightweight processes) to interact directly through common memory locations. Care is required to avoid unintended interactions (races). We consider two simplified models multi-threading and PRAM the message passing model gives each process its own address space. Care is required to distribute the data across these address spaces and to communicate results between them by sending and receiving messages as appropriate. We consider a simplified model, the graph interconnection network

99 Multi-threading model High level model of thread processes using spawn and sync. Does not consider the underlying hardware. Algorithm Algorithm-A begin { } spawn Algorithm-B do Algorithm-B in parallel with this code { other stuff } sync wait here for all previous spawned parallel computations to complete { } end

100 Multi-threading model Many languages (e.g. Java) support the production of separately runnable processes called threads. Each thread looks like it is running on its own and the operating system shares time and processors between the threads. In the multi-threading model, the exact parallel implementation is left to the operating system

101 PRAM model The processors act synchronously SIMD (single instruction multiple data) Several read-write possibilities (exclusive-concurrent) Any mix of ER, EW, CR, CW, e.g. EREW EREW algorithms can be very different from CRCW

102 Interconnection network Graph G = (V, E) Each node i in V is a processor P i Each edge (i, j) in E is a two way link between P i and P j Each processor has its own memory. P X is the value of variable X at node (processor) P Synchronous model (SIMD) P i and P j communicate directly only if joined by an edge (i, j)

103 Concluding remarks and examples Sequential or parallel? Some tasks are intrinsically sequential: e.g. taking a train from London to Manchester Some problems have parts which can be done in parallel: e.g. building the walls of a house Algorithms which split the problem into sub-problems (divide-and-conquer) can work in parallel.

104 Concluding remarks and examples Sequential or parallel? Some tasks are intrinsically sequential: e.g. taking a train from London to Manchester Some problems have parts which can be done in parallel: e.g. building the walls of a house Algorithms which split the problem into sub-problems (divide-and-conquer) can work in parallel. Parallel or Distributed? In both cases many processors run the same program. A parallel system has a central controller. All processors execute the same step of the program at the same time A distributed system has no central control. Processors cooperate to obtain a well regulated system

105 Example of a parallel program #download R from #download R Studio from #install.packages("parallel") intstall parallel package library(parallel) # load R parallel package num_cores=detectcores() # cores on your m/c num_cores #view answer detectcores(logical = FALSE) # how many cores is it really? # Initiate cluster cl <- makecluster(num_cores) #Creates a set of copies of R running in parallel #and communicating over sockets. #apply function over a list in parallel z=parlapply(cl, 1: ,function(x) x^2) stopcluster(cl) #clean up

106 Task manager snapshot

107 Rainfall prediction An international team led by Takemasa Miyoshi of the RIKEN Advanced Center for Computational Science (AICS) has used the powerful K computer and advanced radar observational data to accurately predict the occurrence of torrential rains in localized areas. Today, supercomputer-based weather predictions are typically done with simulations that use grids spaced at least one kilometer apart, and incorporate new observational data every hour. However, due to the roughness of the calculations, these simulations cannot accurately predict the threat of torrential rains, which can develop within minutes when cumulonimbus clouds suddenly develop. Now, an international team led by Takemasa Miyoshi of the RIKEN Advanced Center for Computational Science (AICS) has used the powerful K computer and advanced radar observational data to accurately predict the occurrence of torrential rains in localized areas. The key to the current work, to be published later this month in the August issue of the Bulletin of the American Meteorological Society, is big data assimilation using computational power to synchronize data between large-scale computer simulations and observational data. Using the K computer, the researchers carried out 100 parallel simulations of a convective weather system, using the nonhydrostatic mesoscale model used by the Japan Meteorological Agency, but with 100-meter grid spacing rather than the typical 2-kilometer or 5-kilometer spacing, and assimilated data from a next-generation phased array weather radar, which was launched in the summer of 2012 by the National Institute of Information and Communications Technology (NICT) and Osaka University. With this, they produced a high-resolution three-dimensional distribution map of rain every 30 seconds, 120 times more rapidly than the typical hourly updated systems operated at the world s weather prediction centers today. To test the accuracy of the system, the researchers attempted to model a real case a sudden storm that took place on July 13, 2013 in Kyoto, close enough to Osaka that it was caught by the radars at Osaka University. The simulations were run starting at 15:00 Japanese time, and were tested as pure simulations without observational data input as well as with the incorporation of data every 30 seconds, on 100-meter and 1-kilometer grid scales. The simulation alone was unable to replicate the rain, while the incorporation of observational data allowed the computer to represent the actual storm. In particular, the simulation done with 100-meter grids led to a very accurate replication of the storm compared to actual observations. According to Miyoshi, Supercomputers are becoming more and more powerful, and are allowing us to incorporate ever more advanced data into simulations. Our study shows that in the future, it will be possible to use weather forecasting to predict severe local weather phenomena such as torrential rains, a growing problem which can cause enormous damage and cost lives.

108

109 Thats the end of the introduction!

110 Bibliography I The materials for this lecture were taken and partially adapted from: Algorithms by S. Dasgupta, C. H. Papadimitriou, and U. V. Vazirani. McGraw-Hill Introduction to Parallel Computing by Ananth Grama, George Karypis, Vipin Kumar, and Anshul Gupta. Pearson Design and Analysis of Parallel Algorithms Course Slides by Murray Cole, School of Informatics, University of Edinburgh. CLRS, Introduction to Algorithms Chapter 27 (downloaded) Various articles from WWW