Area Under a Curve (MIPS)

Abstract: MIPS Assembly Program for obtaining the area under a curve formed by joining successive points by a straight line.
Course: Computer Architecture   Instructor: Prof. P. R. Panda

Problem Statement:

Write a MIPS Assembly Program for obtaining the area under a curve formed by joining successive points by a straight line.

Input: (x, y) Co-ordinates of n points, sorted according to the x co-ordinate. Assume integer values for the co-ordinates. Inputs can be taken from keyboard.
Output: Print the area under the curve. The result can be a floating point value as well.

Design Characteristics:

1. Error handling in Input

• MIPS does not have a built-in error handling mechanism.
• Normal integer input allows special characters, string and also no input.
• To restrict coordinates to integers, input taken as string and parsed to get integers.

2. Avoiding Overflow as much as possible

• Integer arithmetic leads to overflows when the result is larger than 32 bits.
• To solve this issue, integer coordinates were converted to doubles and further operations were performed as double operations.

Design Choices:

1. Assumed number of points to be ≥ 1 as without that, the problem does not make mathematical sense. (There would be no curve if there are ≤0 points). For such an input, relevant error message is displayed and execution stopped.
2. Sequential input taken for the points, with prompts for the x-coordinate first, followed by that for the y-coordinate, for each input point.
3. Coordinates not stored in memory, area contributions from each pair computed dynamically, thereby saving memory space.
4. Relevant messages displayed for every input, error, output area and end of execution.
5. Assumed each coordinate to be a 32-bit integer.
6. Assumed area under the x-axis as positive.
7. If x-coordinates of two consecutive points are equal, it is assumed that the curve considered has them in the same order as that given by the user (a different order does not make sense).
8. For the computation of area, the expressions were manipulated to keep as few cases as possible.

Approach of Solution:

First, the number of points to be given is taken as input. Then for each input point, first the x-coordinate is taken and then the y-coordinate. The coordinates are not stored in memory (to conserve space), and the area under them is computed on the fly.

As each point is input, the area under this point and the last point is calculated. Depending on the location of the two points, the 4 major cases identified are reduced to only 2 cases and corresponding areas are computed: (the points are (x1 , y1 ) and (x2 , y2))

1. $y_1$ ∗ $y_2$ ≥ 0 : Area = 1/ 2 ∗($x_2$ − $x_1$)∗(|$y_1$| + |$y_2$|)
2. $y_1$ ∗ $y_2$ < 0 : Area = 1/ 2 ∗($x_2$ − $x_1$)∗($y_1^2$ + $y_2^2$) / (|$y_1$| + |$y_2$|)

The points are initially taken as integers and then converted to doubles using floating point registers. Subsequent calculations are performed using double arithmetic as multiplication of 32 bit coordinates can be 64 bit. A register stores the total area for multiple points, and after input of each point other than the first, the calculated new area is added to this.

As soon as all n points have been taken, the computed area is outputted and execution is stopped. Relevant messages for the same are displayed on the console.

Testing strategy:

1. Random Testing:

Some random inputs are given to program and its output is checked with manual calculations.

2. Boundary Cases:

The different boundary cases are identified and one test input from each such case is checked with manual calculations.

3. Ultimate Test Cases:

Test cases that include all the major boundary cases and hard computations, along with a large number of inputs.

4. Invalid inputs:

Some cases where inputs may not be as per specifications are identified and checked for errors or wrong outputs.