Problem 1: Square Root

For this problem you will write a short assembly program that computes the integral square root of an input number, A, which is initially stored in R0. When the program has terminated the square root should be stored in R1, if the input number is negative the output should be -1. A pseudo-code version of the required algorithm is shown below:

Input A: The number whose square root is to be computed

Output B: The approximate square root - the largest integer such that B*B <= A

B=0

If (A >= 0) {

                     While (B*B <= A) {
                      B = B+1
                   }
}
B = B-1

As part of your script function you should set R0 to the input number A. That way you can rerun your program on different inputs by just editing the script file and rerunning.

While this algorithm is quite simple, you must comment your assembly code. If you do not provide some minor comments, points will be taken off your work. It is best to learn to being using comment appropriately now when it is simple, before it gets complex. This is going to be true for all programs you author in this class.

Problem 2: Fibonacci

In this problem you will write a program that will compute the first 20 numbers in the Fibonacci sequence. (You can refer to Wikipedia for more information on the Fibonacci sequence). Here is the pseudo-code for the procedure:

F_0 = 0
F_1 = 1;

i = 2;
While (i < 20) {
                          F_i = F_(i-1) + F_(i-2);
                          i = i+1
                       }

More specifically your program should write the first 20 Fibonacci numbers into memory starting at address x4000. At the end of your program the addresses x4000 through x4013 will contain the first 20 Fibonacci numbers starting at 0. You may find the list instruction in PennSim useful for examining the contents of memory. You can look at the sum_numbers.asm program for an example of a program that accesses data memory.

Big Hint. You will probably find it convenient to maintain a variable that points to the address in memory you are going to write to next and update this on each iteration. You may also find it useful to use the offset field in the LDR instructions to read values that are near to the current store address.

Problem 3: Prime Finder

In this problem you will write a small program that tests whether a given integer is a prime number or not. Let's call the number we are testing A and let's assume that it starts in R0 - at the end of your program R1 should contain 1 if the number is prime and 0 if it is not.

Here is the pseudo-code for the procedure

If (A <= 1) {
                    PRIME_FLAG = 0;
                    GOTO END
                  }

B = 2;
PRIME_FLAG = 1; // we assume that the number is prime until we prove otherwise

While (B*B <= A) {
                              If (A % B == 0) { // check if A is divisible by B
                              PRIME_FLAG = 0;
                              GOTO END
                             }
B = B+1
}
END