[ answers in web view ]
Name: _______________________________ K E Y
Student ID: _______________________________

In this part of the exam you will be designing and coding a Python program.
The sections of the exam correspond to the sections of a lab writeup.
Total points: 40

Problem Statement:

Design and write a library cplx that implements an abstract data type for complex numbers, similar to what Python has built-in. Your library should provide, at a minimum:

Recall that complex numbers are a + bj, where a and b are real numbers and j=sqrt(-1). Complex numbers multiply like ordinary binomials, but j**2 == -1; collect the real and imaginary terms together.

Docstrings with pre/post-conditions are required for your library and each function. Comments are not required but may be helpful for partial credit if your code isn't perfect.

Problem Suitability: [2]

Numerical calculations with complex numbers are doable by hand for short, simple problems, but a computer is designed to do these mathematical calculations much faster.









Problem Restatement: [3]

Libraries: [2]


Just the random standard library.

Problem Refinement (natural language): [5]



cplx(): takes two parameters, real and imaginary parts, and returns a new "cplx object" -- for our internal representation, we'll use a tuple of two floats.

real(): takes one parameter which is a "cplx object" (really, just a tuple of two floats), and returns the "real part" (really, just the first float in the tuple).

imag(): takes one parameter which is a "cplx object" (really, just a tuple of two floats), and returns the "imaginary part" (really, just the second float in the tuple).

add(): takes two "cplx objects" as parameters, and returns a new "cplx object" (a new tuple): add real part to real part, add imaginary part to imaginary part.

sub(): Similar to add(), but subtract real part from real part, subtract imaginary part from imaginary part.

mul(): Multiply two "cplx objects" according to the rules for complex numbers, i2 = -1. Return the product as a new "cplx object".

intpow(): Raise a complex number to a positive integer power; i.e., iterated multiplication.

rand(): Create and return a new complex number, where the real part is a random number between 0 and 1, and the imaginary part is a random number between 0 and 1.



















Data Tables: [3]

Variables:


No static variables internal to the library (e.g., seed in the pseudorandom library), but our internal representation of a cplx number is a tuple of two floats: (real, imag).


Sample I/O: [2]

For this section, write a short testbed program to demonstrate your library. This need not have user input; it can just have a few test cases hard-coded. The testbed program does not need pseudocode.

(See separate file: cplxtest.py)







User Manual: [5]



cplx(r, i): This is the function you'd use to create a new instance of our ADT -- a new complex number -- when you know the real and imaginary parts. It takes two parameters of type float.

real(): This is a "get" accessor function that returns just the real part of a complex number.

imag(): This is a "get" accessor function that returns just the imaginary part of a complex number.

add(): This operator takes two complex numbers (such as are created by cplx()) and returns the sum of the two. The sum is done component-wise.

sub(): This operator takes two complex numbers (such as are created by cplx()) and returns the difference: c1 - c2.

mul(): This operator takes two complex numbers (such as are created by cplx()) and returns the product, using the rules of complex number multiplication.

intpow(): This operator takes a complex number c and a positive integer n, and raises the complex number to the n-th power, returning the result as a complex number.

rand(): This function takes no parameters, and every time you call it, it returns a different complex number randomly chosen from within the square in the complex plane bounded by 0+0j, 1+0j, 1+1j, 0+1j.



















Pseudocode: [10]



cplx(): Return a new tuple (r,i)

real(): Return the first entry in the tuple: c[0]

imag(): Return the second entry in the tuple: c[1]

add(): Return a new tuple where the first entry is the sum of real parts, the second entry is the sum of imaginary parts: (r1+r2, i1+i2)

sub(): Make a helper function neg() which negates real and imaginary parts: then sub(c1,c2) is just add(c1, neg(c2)).

mul(): Use rules of complex multiplication: (r1*r2 - i1*i2, r1*i2 + r2*i1).

intpow():
	result = 1
	repeat n times:
		result *= c (using our mul() function)
	return result


rand(): Return a new tuple where each entry is a call to random.random().

Code: [8]

(See separate file: cplx.py)