Question

Assignment

You will be designing a calculator complete with user interface to take input from the user, process a response, and produce the output.

Step 1: Present a menu

First thing you should do is present a menu to the user when your program is first ran. Make sure that the operations match the numbers presented below, otherwise the graders won't be able to grade your program.

1. Cartesian distance
2. Vector x matrix
3. Normalize
4. Quit
Enter command:

You will present the menu and wait for the user to input their desired calculation.

It will be easier if you break this up into 6 separate print statements:

print("1. Cartesian distance")
print("2. Vector x matrix")

Recall that print writes the string followed by a newline character to the user and input can take input from the user. For the final prompt, you will want the user to write just to the right of the : followed by a space. Recall that input() can take a string parameter, which will be the prompt to be specified, such as input("Enter command: "). Notice I put a space between the : and the ". This is so that the user writes just to the right of the prompt.

Keep in mind that you need to present this menu every time the user completes a calculation until they select quit.

Step 2: Ask the user for further input

Presenting the menu and letting the user choose is just the first step. However, each calculation will be different, so if you need further input, ask for it. DO NOT CHANGE THE ORDER OF THE VARIABLES FROM BELOW. If you do, then the grader will have a difficult time grading your project since they are expecting the inputs to be specified in a particular order.

For cartesian distance: You need to have four floating point inputs: x1, y1 and x2, y2.

For vector x matrix: You will need 3 floating point inputs for the vector followed by 9 row-major, floating point inputs for the matrix, for a total of 12 floating point. Row major means that m11, m12, and m13 will be the first three floats for the matrix input (i.e., the row is specified first) followed by m21, m22, m23, m31, m32, and m33.

For normalize: You will need 3 floating point inputs for the vector. Normalize will transform a vector into a "unit length" where every value is a fraction of its original value from 0.0 to 1.0.

Ask for input from the user all on one line. This will require you to use input(). Recall that input() will return to you the entire line. However, you will separate the user's input by spaces. You can transform one large string into many segments using input().split(" "). This will create a list of strings. For example, if the user types: 1.0 2.0 3.0, your input() will create a string as "1.0 2.0 3.0". That doesn't help us since we need to be able to get three individual floats. So, we can do: values = input().split(" "). This will now create a list as: ["1.0", "2.0", "3.0"]. We now have converted the large string into three smaller strings. However, recall that we want these to be floats. We can do this several ways, but we can do something like:

for i in range(len(values)):
   values[i] = float(values[i])

This will transform each string into its floating point equivalent. Take note that this will not double check the user's work.

Step 3: Process the result

Now that you have the chosen operation and the operands, produce the result.

Cartesian distance. You may need the math import for this, in particular for the square root function. However, you can also produce the square root by using the ** (power) operator with 0.5. Recall that raising a power to 1/2 means to take the square root of it. However, to make your code more readable, I would suggest using the math module and in particular, the sqrt function inside of it.

the_sqrt = math.sqrt(value)

The cartesian distance is given as the following formula:  $LaTeX: \sqrt{(x_2-x_1)^2+(y_2-y_1)^2}$ $($ x 2 − x 1 ) 2 + ( y 2 − y 1 ) 2

Vector x matrix: You will multiply a 3x3 matrix by a 3-value vector. Notice the pattern of the formula below and use a loop to solve this. Do not hard code all of the calculations. 

$LaTeX: \begin{bmatrix} m_{11} & m_{12} & m_{13} \\ m_{21} & m_{22} & m_{23} \\ m_{31} & m_{32} & m_{33} \\ \end{bmatrix} \times \begin{bmatrix} v_1 \\ v_2 \\ v_3 \end{bmatrix} = \begin{bmatrix} m_{11} \times v_1 + m_{12} \times v_2 + m_{13} \times v_3 \\ m_{21} \times v_1 + m_{22} \times v_2 + m_{23} \times v_3 \\ m_{31} \times v_1 + m_{32} \times v_2 + m_{33} \times v_3 \end{bmatrix}$ $[$ m 11 m 12 m 13 m 21 m 22 m 23 m 31 m 32 m 33 ] × [ v 1 v 2 v 3 ] = [ m 11 × v 1 + m 12 × v 2 + m 13 × v 3 m 21 × v 1 + m 22 × v 2 + m 23 × v 3 m 31 × v 1 + m 32 × v 2 + m 33 × v 3 ]

Normalize will take a 3-value vector and shrink it to unit length. To do this, use the following formula:

$LaTeX: \text{length}=\sqrt{(v_1)^2+(v_2)^2+(v_3)^2} $ $length$ = ( v 1 ) 2 + ( v 2 ) 2 + ( v 3 ) 2

After you calculate the length, you divide each element of the vector by length:

$LaTeX: \text{normal vector} = [\frac{v_1}{\text{length}}, \frac{v_2}{\text{length}}, \frac{v_3}{\text{length}}]$ $normal\; vector$ = [ v 1 length , v 2 length , v 3 length ]

There is a module called numpy that performs a lot of these operations. However, I want you to do this manually so that you can see the power of Python while performing legitimate mathematical operations.

Step 4: Output the result

Output the result the user requested.

Step 5: Repeat

Until the user chooses "quit", keep repeating calculations.

One thing to keep in mind is always to error check the user. Don't let them crash your program, and always ask the user to reinput values that were not properly inputted.