π / 4 = 1 - (1/3) + (1/5) - (1/7) + (1/9) - (1/11) + ...

There is another novel approach to calculate π. Imagine that you have a dart board that is 2 units square. It inscribes a circle of unit radius. The center of the circle coincides with the center of the square. Now imagine that you throw darts at that dart board randomly. Then the ratio of the number of darts that fall within the circle to the total number of darts thrown is the same as the ratio of the area of the circle to the area of the square dart board. The area of a circle with unit radius is just π square unit. The area of the dart board is 4 square units. The ratio of the area of the circle to the area of the square is π / 4.

To simuluate the throwing of darts we will use a random number generator.
The Random module has several random number generating functions that can be
used. For example, the function *uniform(a, b)* returns a floating point
random number in the range a (inclusive) and b (exclusive).

Imagine that the square dart board has a coordinate system attached to it. The upper right corner has coordinates ( 1.0, 1.0) and the lower left corner has coordinates ( -1.0, -1.0 ). It has sides that are 2 units long and its center (as well as the center of the inscribed circle) is at the origin.

A random point inside the dart board can be specified by its x and y coordinates. These values are generated using the random number generator. The way we achieve that is:

xPos = random.uniform (-1.0, 1.0) yPos = random.uniform (-1.0, 1.0)

To determine if a point is inside the circle its distance from the center
of the circle must be less than the radius of the circle. The distance of
a point with coordinates ( xPos, yPos ) from the center is *math.hypot
(xPos, yPos)*. The radius of the circle is 1 unit.

The program that you will be writing will be called CalculatePI. It will have the following structure:

import math import random def computePI ( numThrows ): ... def main (): ... main()Your function

In your function *main()* you want to experiment and see if the accuracy
of PI increases with the number of throws on the dartboard. You will compare
your result with the value given by math.pi. The quantity *Difference*
in the output is your calculated value of PI minus math.pi. Use the following
number of throws to run your experiment - 100, 1000, 10,000, 100,000, 1,000,000,
and 10,000,000. You will call the function *computePI()* with these numbers
as input parameters. Your output will be similar to the following, i.e. the
actual values of your *Calculated PI* and *Difference* will be
different but close to the ones shown:

Computation of PI using Random Numbers num = 100 Calculated PI = 3.320000 Difference = +0.178407 num = 1000 Calculated PI = 3.080000 Difference = -0.061593 num = 10000 Calculated PI = 3.120400 Difference = -0.021193 num = 100000 Calculated PI = 3.144720 Difference = +0.003127 num = 1000000 Calculated PI = 3.142588 Difference = +0.000995 num = 10000000 Calculated PI = 3.141796 Difference = +0.000204 Difference = Calculated PI - math.piYour output

The program that you will be writing will be called CalculatePI. We will be looking at good documentation, and adherence to the coding conventions discussed in class. Your file CalculatePI.py will have the following header:

# File: CalculatePI.py # Description: # Student Name: # Student UT EID: # Course Name: CS 303E # Unique Number: # Date Created: # Date Last Modified:

Use the
turnin system to submit your **CalculatePI.py** file.
The proctors should receive your work by 11 PM on Friday, 18 October 2013.
There will be substantial penalties if you do not adhere to the
guidelines. The TA in charge of this assignment is Lee Thompson
(parnell@cs.utexas.edu).

- Your Python program should have the header with the proper documentation.
- Your code must run before submission.
- You should be submitting your file through the web based
*turnin*program. We will not accept files e-mailed to us. - Here is the Grading Criteria.