Program Design Approaches & Branching Structures

1. Chapter 3 Program Design And Branching Structures

2. Design approaches • On-the-fly • OK with simple programs • Simple programs can be debugged easily • Top-down design • Necessary for large/complex programs • Task  subtasks • Test each subtask individually, then combine all • Debugging is easier

3. Top-down-design steps • Clearly state the problem • Define required inputs and produced outputs • Design algorithm to be used • Turn algorithm into Fortran statements • Test program

4. Clearly state the problem • Write a program which calculates the total energy of a falling object. • Not clear enough • Write a program which prompts the user to enter the parameters of a falling object (height, mass, and velocity), calculates the total energy of the object (potential + kinetic) and prints on the screen for the user the total energy of the object. • Clearer

5. 2. Inputs & Outputs • In the previous example: • Inputs: • mass • height • velocity • Outputs: • Total energy of the falling object

6. 3. Algorithm • Prompt (ask) user for inputs • Compute the total energy using the equations: • Gravity = 9.8 • Potential energy = mass * gravity * height • Kinetic energy = 0.5 * mass * velocity2 • Total energy = Potential energy + Kinetic energy

7. 4. Algorithm  Fortran statements PROGRAM Energy implicit none REAL,parameter :: gravity=9.8 REAL :: height, mass, velocity REAL :: Potential_Energy, Kinetic_Energy, Total_Energy write (*,*) "Please enter the height, mass, and velocity of the object" read (*,*) height, mass, velocity Potential_Energy = mass * gravity * height Kinetic_Energy = 0.5 * mass * velocity**2 Total_Energy = Potential_Energy + Kinetic_Energy write (*,*) "The toal energy of the object = ", Total_Energy, "Joul." END PROGRAM

8. 5. Testing • Test in the LAB • For big programs: • ALPHA release • First complete version • Tested by the programmer and close friends • All possible ways of using the program are tested • BETA release • Serious bugs in ALFA release is removed • Tested by users who need the program • Program is put under many different conditions • Released for general use • Released for everyone to use

9. Standard Forms of Algorithms:Pseudocode and Flowcharts • An algorithm is composed of constructs. • Constructs can be described using: • Pseudocode • Flowcharts • Advantages: • Standard form: Easy to understand by others • Making changes in the program is easier • Debugging is easier

10. Standard Forms of Algorithms:Pseudocode and Flowcharts • Pseudocode: • Describe algorithm using a mix of Fortran language and English language • Example: Prompt user to enter height, mass, and velocity Read height, mass, and velocity Gravity  9.8 Potential energy  mass * gravity * height Kinetic energy  0.5 * mass * velocity2 Total energy  Potential energy + Kinetic energy Write Total energy on the screen

11. Standard Forms of Algorithms:Pseudocode and Flowcharts • Flowcharts: • Describe algorithm graphically • Standard shapes are used for each type of construct

14. Logical Variables and Constants • LOGICAL constants take one of 2 values: true / false • Example: • Logical, parameter:: correct = .TRUE. • Logical, parameter:: wrong = .FALSE. • LOGICAL constants are rarely used

15. Logical Variables and Constants • LOGICAL variables are declared like other variables • Example: • LOGICAL :: var1, var2, var3 • LOGICAL :: var4 • LOGICAL variables are more used than LOGICAL constants

16. ERRORS … • Invalid syntax • correct = .TRUE • incorrect = FALSE.

17. Logical Statements • Logical statement form: • Logical_variable_name = logical experession • Example: • PROGRAM PASS • IMPLICIT NONE • CHARACTER (len=4) :: PASSWORD • LOGICAL :: CHECK • WRITE (*,*) “ What is the password? “ • READ (*,*) PASSWORD • CHECK = ( PASSWORD == ‘EASY’ ) • WRITE (*,*) CHECK • END PROGRAM

18. Logical Statements.. Relational Operators • Relational operators: • compare two operands and produce logical results (T/F) • A1 op A2 • A1 & A2: can be either numerical or character • op: == /= • > < • >= <= • Examples: • 3 < 4 .TRUE. • 3 <= 4 .TRUE. • 4 <= 3 .FALSE. • ‘A’ < ‘B’ .TRUE. • 4 < ‘A’ ????? • ILLEGAL (ERROR)

19. Logical Statements.. Relational Operators • Example: • PROGRAM PASS • IMPLICIT NONE • INTEGER :: x, y • LOGICAL :: compare • WRITE (*,*) “Enter numbers (x, y) to check if “ • WRITE (*,*) “x > y “ • WRITE (*,*) “ “ • READ (*,*) x, y • CHECK = (x > y) • WRITE (*,*) “ The statement x > y is “, CHECK • END PROGRAM

20. Logical Statements.. Combinational Operators • Combinational operators: • compare two operands and produce logical results (T/F) • A1 op A2 • A1 & A2: logical operands (.TRUE. / .FALSE.) • op: .AND. .OR. .EQV. .NEQV. .NOT • Truth table for binary combinational logic operators: • L1 .FALSE. .FALSE. .TRUE. .TRUE. • L2 .FALSE. .TRUE. .FALSE. .TRUE. • L1 .AND. L2 .FALSE. .FALSE. .FALSE. .TRUE. • L1 .OR. L2 .FALSE. .TRUE. .TRUE. .TRUE. • L1 .EQV. L2 .TRUE. .FALSE. .FALSE. .TRUE. • L1 .NEQV. L2 .FALSE. .TRUE. .TRUE. .FALSE. • L1 .TRUE. .FALSE. • .NOT. L1 .FALSE. .TRUE.

21. Logical Statements.. Combinational Operators • Exercise: L1 = .TRUE. L2 = .TRUE. L3 = .FALSE. • Logical expression • .NOT. L1 • .FALSE. • L1 .OR. L3 • .TRUE. • L2 .NEQV. L3 • .TRUE.

22. Logical Statements.. Evaluation order • When evaluating an expression, follow these rules: • 1. Arithmetic operations (e.g. (3 + 4 * ( 2 / 5)) • 2. Relational logic operations (e.g. ( 3 > 4 ) ) • 3. Combinational logic operations, evaluate in this order: • .NOT. (left to right) • .AND. (left to right) • .OR. (left to right) • .EQV. and .NEQV. (left to right) • Parenthesis can change order of evaluation

23. Logical Statements.. Evaluation order • Exercise: L1 = .TRUE. L2 = .TRUE. L3 = .FALSE. • Logical expression • .NOT. ( 3 > 4 ) • .TRUE. • L3 .OR. ( (2 * 5) < 12 ) • .TRUE. • L2 .NEQV. ( L3 .AND. ( 3 /= 4)) • .TRUE.