Basic Building Blocks

In all ways of life, the easiest way to solve most problems is to

break them down into smaller sub_problems and then to deal

with each of these in turn, further sub-dividing these subproblems

as necessary.

Seven Golden Rules

Always plan ahead

Develop in stages

Modularize

Keep it simple

Test throughly

Document all programs

Enjoy your programming

Programs and modules Main program unit

program name

use statements...Specification statements...Executable statements...

end program name

Modules

Programs for solving complex problems should be designed in a modular fashion.

The problem should be divided into simpler subproblems, so that the subprograms can be written to solve each of them.

Every program must include exactly one main program and may also include one or more modules.

Modules•Modules are a second type of program unit.

•The basic structure of a module is similar to the main program unit.

•The initial module statement of each module specifies the name of that module based on the F language rules.

•A module unit ends with an end module statement incuding its name.

•A module does not contain any executable statements.

•A module may contain any number of subprograms which are seperated from the other statements by a contain statement.

Module program unit

module name

use statements...Specification statements.

contains(Procedure definitions)

subprogram_1subprogram_2..subprogram_n

end module name

ProceduresA special section of program which is, in some way, referred to whenever required, is known as a “procedure”. Programs

     can be written by the programmer     by some other person who allows the programmer to use them    can be a part of the F language itself (i.e. intrinsic procedures whose names are reserved words must always be written in lower case). Subprograms can also be categorized as  subroutines ( there are 5 intrinsic subroutines )  functions ( create only a single result ; there are 97 intrinsic functions available in F )

Procedures Divide and rule!

Main program Procedure 1

Procedure 2 Procedure 3

Procedures Procedures - origin

“Write your own” (homemade) Intrinsic (built-in, comes with F )

sin(x), cos(x), abs(x), … Written by someone else (libraries)

Procedures (subprograms) – form Functions Subroutines

Procedures The main program and any subprogram need

never be aware of the internal details of any other program or subprogram!

Main program

Procedure 1

Procedure 2Procedure 3

Procedures

name (argument_1, argument_2, ...)

Examples:

a + b * log (c)

-b + sqrt ( b * b – 4.0 * a * c)

ProceduresA) PROBLEM : A farmer has a triangular field which he wishes to sow with wheat.

Write a program that reads the lenghts of the 3 sides of the field (in meters) and the sowing density (in grams per square meters)

Print the number of 10 kilo bags of wheat he must purchase in order to sow the whole field.

B.) ANALYSIS : STRUCTURE PLAN of the PROBLEM

    read lenghts of the sides of the field ( a, b, c ) and calculate the area of the field

area = ( s (s-a)(s-b)(s-c) ) ½

2s = a + b + c

•        read the sowing density

•       calculate the quantity of wheat seed required

•       calculate the number of 10 kilo bags this represents

C) SOLUTION

program wheat_sowing

! This program calculate quantity of wheat required to sow a triangular field

! Variable declarations

real : : a, b, c,s, area, density, quantity

integer : : num_bags

! read the lengths of the sides of the field

print *, “type the lengths of the 3 sides of the field in metres : “

read *, a, b, c

! calculate the area of the field

s = 0.5 * ( a + b + c )

area = sqrt( s * (s - a)*(s - b)*(s - c) )

! read sowing density

print *, “ What is the sowing density (gms/sq.m) ?”

read *, density

! calculate quantity of wheat and the number of 10 kilo bags

! round up more than 1 kg

quantity = density * area

num_bags = 0.0001 * quantity + 0.9

! print results

print *, “the area of the field is “, area,” sq. metres”

print *, “and “, num_bags,” 10 kilo bags will be required”

end program wheat_sowing

SubprogramsFunctions : Functions may, of course, be provided by the user and they are normally implemented by means of an F subprogram which is physically placed within a module as is explained in Modules.

 

On the other hand, very important principle which applies to all procedures in F is that the main program and any subprograms need never be aware of the internal details of any other program unit or subprograms .

A function subprogram can be called by

        the main program

        another subroutine subprogram

        another function

Functions function name (d1, d2, …) result(result_name)

Specifications part..

Execution part end function name Variables

Internal (local) variables Result variable (keyword result) Dummy argument (keyword intent(in))

attribute

Functionsfunction cube_root result(root)! A function to calculate the cube root of ! a positive real number! Dummy argument declaration

real, intent(in) :: x! Result variable declaration

real :: root! Local variable declaration

real :: log_x! Calculate cube root by using logs

log_x = log(x)root = exp(log_x/3.0)

end function cube_root

Subroutinessubroutine roots (x, square_root, cube_root, fourth_root, & fifth_root)! Subroutine to calculate various roots of positive real! Number supplied as the first argument, and return them in! the second to fifth arguments

! Dummy argument declarations real, intent(in) :: x real, intent(out) :: square_root, cube_root, & fourth_root, fifth_root ! Local variable declaration real :: log_x ! Calculate square root using intrinsic sqrt square_root = sqrt(x) ! Calculate other roots by using logs log_x = log(x) cube_root = exp(log_x/3.0) fourth_root = exp(log_x/4.0) fifth_root = exp(log_x/5.0)end subroutine roots

Subroutines call name (arg1, arg2, …) intent(in), intent(out), intent(inout)

Arguments Actual arguments in the calling

program Dummy arguments in the subroutine

or function The order and types of the actual

arguments must correspond exactly with the order and types of the corresponding dummy arguments

Objects Local variables vs. global variables private vs. public objects

Saving the values of local objects Local entities within a procedure are not accessible

from outside that procedure Once an exit has been made, they cease to exist If you want their values to ‘survive’ between calls,

usereal, save :: list of real variables

real, save::a, b=1.23, c

Integer, save::count=0

Example

MAIN PROGRAM

program ……..

real : : Alpha, Beta, Gamma

.

.

Alpha = Fkt ( Beta, Gamma )

.

.

end program ……….

 

 

FUNCTION SUBPROGRAM

function Fkt ( x, y )

real : : Fkt

real : : x, y

Fkt = x ** 2 - 2.5 * y + 3.7 * y ** 2

x = 0.0

end function Fkt

Example: Write a subprogram which calculates the cube root of a positive real number

MAIN PROGRAM

program test_cube_root

use maths

real : : x

print *, “Type a positive real number”

read *, x

Print *, “ The cube root of “,x,” is “, cube_root(x)

.

a = b * cube_root(x) + d

.

end program test_cube_root

module maths

Public::cube_root

contains

function cube_root (x) result (root)

! a function to calculate the cube root of a positive real number

! Dummy arguments

real , intent (in) : : x

! Result variable declaration

real : : root

! Local variable declaration

real : : log_x

! Calculate cube root by using logs

log_x = log (x)

root = exp (log_x / 3.0)

function cube_root

end module maths

Attributes intent (in): the dummy argument only provides

information to the procedure and is not allowed to change its value any way

intent (out): the dummy argument only returns information from the procedure to the calling program

intent (inout): the dummy argument provides

information in both directions

Examples of subprograms

Write a program using either subroutine or function:

read the edges of a rectangle, write a subprogram which

calculate area of rectangle

!this program is calculates area of a rectangle

!using subroutine

program area_calculation

use rec

real::a,b,al

print *, "enter two edges of the rectangle"

read *, a,b

call area (a,b,al)

print *, "a=",a

print*,"b=",b

print *, "area_of_rectangle=",al

endprogram area_calculation

module rec

public::area

contains

subroutine area(a,b,al)

real, intent(in)::a,b

real, intent (out)::al

al=a*b

return

endsubroutine area

end module rec

program subprogram

!this program is calculates area of a rectangle

program area_calculation

use rec

real::a,b,al

print *, "enter two edges of the rectangle"

read *, a,b

al=area (a,b)

print *, "a=",a

print*,"b=",b

print *, "area_of_rectangle=",al

endprogram area_calculation

module rec

public::area

contains

function area(a,b)result (al)

real, intent(in)::a,b

real::al

al=a*b

return

endfunction area

end module rec

program subprogram

Write a program using either subroutine or function:

read the three edges of a triangle,

write a subprogram which calculate area of triangle

!this program calculate area of a triangle

!using subroutine

program triangle_area

use ak

real :: a,b,c,al

print *,"a,b,c"

read *,a,b,c

call alan(a,b,c,al)

print *,al

end program triangle_area

module ak

public :: alan

contains

subroutine alan(a,b,c,al)

real, intent (in)::a,b,c

real, intent (out)::al

real :: s

s=(a+b+c)/2

al=sqrt(s*(s-a)*(s-b)*(s-c))

return

end subroutine alan

end module ak

program subprogram

program subprogram

program triangle_area

use ak

real :: a,b,c,al

print *,"a,b,c"

read *,a,b,c

al= alan(a,b,c)

print *,al

end program triangle_area

module ak

public :: alan

contains

function alan(a,b,c) result (al)

real, intent(in) :: a,b,c

real :: al

real :: s

s=(a+b+c)/2.0

al=sqrt(s*(s-a)*(s-b)*(s-c))

return

end function alan

end module ak

HOMEWORK 2 Dead Line : 28 / 03 / 2001 

PROBLEM

Consider a geometrical body which consists of a steel-cylinder and a cone of lead having the same radius. Then, prepare a computer program having the structure described in below :

The main program will: read the input values (radius r=50cm, height of the cylinder, h1=300cm, height of the cone h2 = 150cm, density of steel, d1 = 7.85 t/m3, density of lead d2 = 11.40 t/m3 )

calculate the total volume of the given body

calculate the total weight of the given body

finally print,

the input values

the volume of the cylinder

the weight

the volume of the cone

the weight of the cone

the total volume of the given body

the total weight of the given body

using list directed output command including the above-given expressions for the input values and the results obtained.

A function sub-program will

calculate only the bottom surface area

 

A subroutine sub-program will calculate

the volume of the cylinder

the weight of the cylinder

 

Another subroutine sub-program will calculate

the volume of the cone

the weight of the cone