RANGE AND PRECISION

2. EXAMPLE PROBLEM PYTHAGORAS

2.1. Requirements

Given the length of the "opposite" (O) and "adjacent" (A) sides of a right angled triangle (see right) determine the "hypotenuse" (H) using Pythagoras theorem:

H^2 = O^2 + A^2

Assume sides are given as floating point numbers between 0.0 and 100.0 and that an accuracy of 4 decimal places is required

2.2. Design

Using a top down analysis of the problem we can identify the operations shown below:

These operations are trivial enough to be encompassed by a single procedure:

1. PYTHAGORAS (top level procedure) - read in short sides and calculate and output long side.

   NAME	DESCRIPTION	TYPE	RANGE
   OPPOSITE	Input variable	FLOAT	0.0..100.0
   ADJACENT	Input variable	FLOAT	0.0..100.0
   HYPOTENUSE	Global variable	FLOAT	0.0..100.0

A Nassi-Shneiderman design is presented to the right.

2.3. Implementation

The implementation of the design is as follows:

-- PYTHAGORAS
-- 6 August 1997
-- Frans Coenen
-- Dept Computer Science, University of Liverpool

with TEXT_IO, GENERIC_ELEMENTARY_FUNCTIONS;
use TEXT_IO;

procedure PYTHAGORAS is
        OPPOSITE, ADJACENT: FLOAT range 0.0..100.0;
        HYPOTENUSE: FLOAT;
        package FLOAT_INOUT is new FLOAT_IO(FLOAT);
        use FLOAT_INOUT;
        package MATH_FUNC is new GENERIC_ELEMENTARY_FUNCTIONS(FLOAT);
        use MATH_FUNC;
begin
-- Input opposite and adjacent side
        PUT_LINE("Input opposite and adjacent sides: ");
        GET(OPPOSITE);
        GET(ADJACENT);
-- Calculate hypotenuse
        HYPOTENUSE := OPPOSITE**2 + ADJACENT**2;
        HYPOTENUSE := SQRT(HYPOTENUSE);
-- Output hypotenuse
        PUT("Hypotenuse is: ");
        PUT(HYPOTENUSE, FORE=>3, AFT=>4, EXP=>0);
        NEW_LINE;
end PYTHAGORAS;

Notes:

3. EXAMPLE PROBLEM 2-D GEOGRAPHIC DISTANCE

3.1 Requirements

Design and implement an Ada program that determines the geographical distance between two points located on a geographic plane. The points are referenced using the standard {X,Y} Cartesian coordinate system founded on a 0 origin (see below). The geographic space of interest measures 100x100. X and Y Coordinates can therefore range from 0.0 to 100.0 inclusive. Distances should be determined to within 4 decimal places.

3.2 Design

The distance between two two-dimensional points is given by:

DISTANCE = SQRT(X^22 + Y^2)

where X and Y respectively represent the difference between the pairs of x and y coordinates for the two points. To address this problem we can identify a number of operations as indicated by the top-down analysis presented below:

These operations are simple enough to be combined into a single procedure:

1. GEO_DIST_2D (top level procedure) - input data, and calculate and output distance.

   NAME	DESCRIPTION	TYPE	RANGE
   X1	Input variable	FLOAT	0.0..100.0
   Y1	Input variable	FLOAT	0.0..100.0
   X2	Input variable	FLOAT	0.0..100.0
   Y2	Input variable	FLOAT	0.0..100.0
   X_DIFF	Global variable	FLOAT	Default
   Y_DIFF	Global variable	FLOAT	Default
   DISTANCE	Global variable	FLOAT	Default

The design of this procedure is indicated by the Nassi-Shneiderman chart presented below.

3.3. Implementation

-- 2D GEOGRAPHIC DISTANCE
-- 4 August 1997
-- Frans Coenen
-- Dept Computer Science, University of Liverpool

with TEXT_IO, GENERIC_ELEMENTARY_FUNCTIONS;
use TEXT_IO;

procedure GEO_DIST_2D is
        X1, Y1, X2, Y2: FLOAT range 0.0..100.0;
        X_DIFF, Y_DIFF, DISTANCE: FLOAT;
        package FLOAT_INOUT is new FLOAT_IO(FLOAT);
        use FLOAT_INOUT;
        package MATH_FUNC is new GENERIC_ELEMENTARY_FUNCTIONS(FLOAT);
        use MATH_FUNC;
begin
-- Input coordinates for point 1
        PUT_LINE("Input X and Y coordinates for point 1: ");
        GET(X1);
        GET(Y1);
-- Input coordinates for point 2
        PUT_LINE("Input X and Y coordinates for point 2: ");
        GET(X2);
        GET(Y2);
-- Calculate differences and distance
        X_DIFF := abs(X1-X2);
        Y_DIFF := abs(Y1-Y2);
        DISTANCE := SQRT(X_DIFF**2 + Y_DIFF**2);
-- Output distance
        PUT("Distance is: ");
        PUT(DISTANCE, FORE=>3, AFT=>4, EXP=>0);
        NEW_LINE;
end GEO_DIST_2D;

Note that the abs operator is a standard numeric operator which has one operand that can be of any arbitrary numeric type. The operator calculates the absolute value (or magnitude) of the operand, i.e. the operand itself if it is positive, and the negated operand if it is negative.

3.4. Testing

BVA testing: Use BVA to test limits of input values. Appropriate values for X1, Y1, X2 and Y2 are -0.1, 0.1, 99.9 and 100.1 (just above and below the range limits). A set of test cases of this form is presented in the table to the right. The * symbol indicates where no further input is required as the code is expected to fail after the previous input.

Arithmetic testing: We should also carry out a set of numeric tests to check the workings of the arithmetic expressions. This could be done by generating a set of cases combining every possible combination of zero and positive sample input value (negative values are precluded in this case), i.e. 2 x 2 x 2 x 2 = 16 test cases. This would be rather tedious (and with more inputs impractical). We can reduce the amount of test cases required by investigating more closely the arithmetic operations we wish to check. There are three of these:

Commencing with the two difference calculations, we note that each is carried out independently from the other and thus can be tested simultaneously. Each should be tested with combinations of positive and zero sample values. An outline set of required test cases is given in the table to the right.

Turning to the Pythagoras calculation this should be tested with sample values for X_DIFF and Y_DIFF comprising all possible combinations of zero and positive value (we cannot have a negative difference) as shown in the table to the right. Test cases required to check the difference calculation already identify the situation where both difference values are zero and both difference values are positive. We therefore simply need to derive two test cases where one or the other difference value is zero .

An appropriate set of numeric test cases with respect to the foregoing is given below. Note that we have reduced the number of arithmetic tests from 16 to 6. The first four of the following address the difference calculations and also the Pythagoras calculation where both differences are 0 and both differences are positive. The final two test cases are designed to exercise the Pythagoras calculation where one of the differences is zero and the other is positive (and vice-versa).

Limit testing: We should also test the operations of the systems at the limits for the input data. Notionally there are four tests for each difference calculation covering every combination of 0.0 and 100.0 input. However, the above arithmetic test cases have considered the case where inputs are all 0.0. Therefore we only need to test combinations where one or both of the input is 100.0. An appropriate set of test cases is given in the table below.

Data validation: Finally we should carry out some tests using deliberately spurious data.